Задача

Дано дерево на $$$n$$$ вершинах, в вершине $$$v$$$ записано число $$$a_v$$$. Поступают запросы двух видов:

1. Найти максимальное число на кратчайшем пути из вершины $$$u$$$ в вершину $$$v$$$.
2. Сделать $$$a_v = x$$$.

Варианты решений

Эта задача очень известна, поэтому скорее всего вам в голову пришло решение, использующее Heavy-Light Decompositon (или Link-Cut Tree, если вы большой любитель splay-деревьев). Первый вариант в стандартной реализации работает за $$$O(log^2~ n)$$$, второй работает за $$$O(log~ n)$$$, однако для его использования нужны более специфичные знания. Хочется добиться более хорошей асимптотики HLD, используя какие-то несложные идеи. Оказывается, что это возможно.

$$$O(log^2~ n)$$$ на запрос

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

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

Давайте покажем, что на любой вертикальный путь можно разбить на $$$O(log~ n)$$$ частей, каждая из которых полностью лежит в одном пути. Будем подниматься из нижней вершины вверх. Если мы сменили текущий путь, это означает, что мы перешли по легкому ребру, а значит размер поддерева, в котором мы сейчас находимся, увеличился в хотя бы $$$2$$$ раза. Так как вершин в дереве $$$n$$$, мы не сможем сменить путь более чем $$$log~ n$$$ раз. А значит мы добились того, чего хотели.

Теперь, что бы ответить на запрос, достаточно узнать максимум на путях $$$(lca(u, v), u)$$$ и $$$(lca(u, v), v)$$$. Это можно сделать, например, используя дерево отрезков (отсюда $$$O(log^2~n)$$$).

Для смены $$$a_v$$$ достаточно сделать один запрос в дерево отрезков.

В данном посте не будем рассматривать стандартную реализацию HLD, так как есть люди, которые сделают это лучше меня.

$$$O(log~ n)$$$ на запрос

Для доказательства асимптотики в предыдущем пункте мы использовали тот факт, что переходя с одного пути на другой, поддерево увеличивается хотя бы в $$$2$$$ раза. Развивая эту идею, можно добиться лучшей асимптотики.

А что, если попытаться сделать такую структуру, что взятие максимума на каком-то отрезке пути на каждой своей операции увеличивает какую-то величину $$$ \le n$$$ хотя бы в $$$2$$$ раза? Тогда мы как раз добьемся того, чего хотели.

Основная проблема кроется в дереве отрезков. Оно отвечает на запрос за $$$O(log~ n)$$$ (или $$$O(log(r - l))$$$, если использовать реализацию снизу). Это происходит из-за того, что мы делим текущий отрезок пополам никак не пользуясь размерами поддеревьев. Давайте это исправим. Для этого нам потребуется использовать вместо дерева отрезков другое бинарное дерево.

Рассмотрим какой-то путь декомпозиции $$$v_1, v_2, \dots, v_k$$$. Давайте мысленно уберем ребра между соседними вершинами, а за $$$w_i$$$ обозначим размер поддерева $$$v_i$$$, которое осталось у вершины. Пусть $$$W = \sum_{i=1}^{k} w_i$$$. Найдем первый такой индекс $$$j$$$, что $$$\sum_{i=1}^{j} w_i \ge \frac{W}{2}$$$. Сделаем вершину $$$v_j$$$ корнем нашего бинарного дерева, а для определения левого и правого ребенка рекурсивно запустимся от левой и правой половины пути. Теперь мы умеем строить какое-то странное дерево, но непонятно чем оно лучше обычного дерева отрезков.

Для начала подумаем, как в таком дереве отвечать на запрос максимума на отрезке. Для этого посмотрим на вершины пути, которые являются самой левой и самой правой вершиной отрезка ($$$l$$$ и $$$r$$$), на котором нам нужно посчитать максимум. Найдем их позицию в построенном нами дереве. Теперь, чтобы ответить на запрос, нам надо подняться от $$$l$$$ до $$$lca(l, r)$$$ в нашем дереве, обновляя ответ через значение текущей вершины, а также значение ее правого поддерева, если сама вершина является левым сыном (для меня, такой способ ответа на запрос сильно напомнил дерево отрезков снизу). Аналогично нужно подняться от $$$r$$$.

Осталось посчитать асимптотику. Если мы посмотрим на $$$\sum w_i$$$ в текущем поддереве нашей структуры, то в силу построения дерева при переходе в предка она увеличивается в хотя бы $$$2$$$ раза. Тогда если следить за такой величиной, можно понять, что мы добились $$$O(log~ n)$$$ на запрос, так как если мы поднимаемся при ответе на запрос в текущем пути данное значение увеличивается хотя бы $$$2$$$ раза, а также, если мы переходим по легкому ребру, $$$\sum w_i$$$ снова увеличивается в два раза (теперь уже в силу изначального разбиения на пути). Получается, мы добились того, чего хотели (довольно очевидно, что данная величина не может превышать $$$n$$$).

Для обновления $$$a_v$$$ достаточно взять нужную вершину в построенном на пути бинарном дереве и обновить всех ее предков (доказательство времени работы аналогично).

Для большего понимания, предлагаю ознакомиться с кодом:

#include <bits/stdc++.h>

using namespace std;

#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()

const int MAXN = 101010;
vector<int> g[MAXN];
int a[MAXN], tin[MAXN], tout[MAXN], p[MAXN], sz[MAXN], head[MAXN], w[MAXN], id[MAXN], path_ind[MAXN], tree_id[MAXN];

vector<vector<int>> path;

int timer = 0;
void precalc(int v, int prv) {
    p[v] = prv;
    sz[v] = 1;
    tin[v] = timer++;

    for (auto u : g[v]) {
        if (u == prv) continue;
        precalc(u, v);
        sz[v] += sz[u];
    }

    tout[v] = timer;
}

bool is_anc(int u, int v) {
    return tin[u] <= tin[v] && tout[v] <= tout[u];
}

void hld(int v) {
    path_ind[v] = path[id[v]].size();
    path[id[v]].push_back(v);

    int mx = -1;
    for (auto u : g[v]) {
        if (u == p[v]) continue;
        if (mx == -1 || sz[mx] < sz[u]) mx = u;
    }

    w[v] = sz[v];
    for (auto u : g[v]) {
        if (u == p[v]) continue;
        if (u == mx) {
            w[v] -= sz[u];
            id[u] = id[v];
            head[u] = head[v];
        } else {
            id[u] = path.size();
            path.emplace_back();
        }
        hld(u);
    }
}

struct node {
    int p = -1, l = -1, r = -1;
    int x = 0, mx = 0, d = 0;
};
node t[MAXN];
int SIZE = 0;

int mx(int i) {
    return (i == -1 ? 0 : t[i].mx);
}

void update(int v, int x) {
    v = tree_id[v];
    t[v].x = x;
    while (v != -1) {
        t[v].mx = max({t[v].x, mx(t[v].l), mx(t[v].r)});
        v = t[v].p;
    }
}

int path_get(int l, int r) {
    l = tree_id[l];
    r = tree_id[r];

    int lca, nl = l, nr = r;
    while (t[nl].d > t[nr].d) nl = t[nl].p;
    while (t[nr].d > t[nl].d) nr = t[nr].p;
    while (nl != nr) nl = t[nl].p, nr = t[nr].p;
    lca = nl;

    int ans = max({t[l].x, t[lca].x, t[r].x});
    if (l != lca) ans = max(ans, mx(t[l].r));
    if (r != lca) ans = max(ans, mx(t[r].l));

    while (l != lca) {
        if (t[l].p != lca && t[t[l].p].l == l) {
            ans = max({ans, t[t[l].p].x, mx(t[t[l].p].r)});
        }
        l = t[l].p;
    }
    while (r != lca) {
        if (t[r].p != lca && t[t[r].p].r == r) {
            ans = max({ans, t[t[r].p].x, mx(t[t[r].p].l)});
        }
        r = t[r].p;
    }

    return ans;
}

void up(int& a, int& b, int& res) {
    while (!is_anc(head[a], b)) {
        res = max(res, path_get(head[a], a));
        a = p[head[a]];
    }
}

int get(int u, int v) {
    int ans = 0;

    up(u, v, ans);
    up(v, u, ans);
    if (tin[u] > tin[v]) swap(u, v);
    ans = max(ans, path_get(u, v));

    return ans;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) cin >> a[i];
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    precalc(1, 0);
    for (int i = 1; i <= n; i++) head[i] = i;
    path.emplace_back();
    hld(1);

    for (int path_id = 0; path_id < path.size(); path_id++) {
        auto build_tree = [&](auto build_tree, int l, int r, int d) {
            if (l > r) return -1;

            int sum = 0;
            for (int i = l; i <= r; i++) sum += w[path[path_id][i]];
            int root = -1;
            int cur = 0;
            for (int i = l; i <= r; i++) {
                cur += w[path[path_id][i]];
                if (2 * cur >= sum) {
                    root = i;
                    break;
                }
            }
            int v = path[path_id][root];
            int ind = SIZE++;
            tree_id[v] = ind;

            t[ind].x = a[v];
            t[ind].d = d;
            t[ind].l = build_tree(build_tree, l, root - 1, d + 1);
            t[ind].r = build_tree(build_tree, root + 1, r, d + 1);
            t[ind].mx = max({a[v], mx(t[ind].l), mx(t[ind].r)});
            if (t[ind].l != -1) t[t[ind].l].p = ind;
            if (t[ind].r != -1) t[t[ind].r].p = ind;

            return ind;
        };
        build_tree(build_tree, 0, path[path_id].size() - 1, 0);
    }

    int q;
    cin >> q;
    for (int i = 0; i < q; i++) {
        char t;
        cin >> t;
        if (t == '!') {
            int v, x;
            cin >> v >> x;
            update(v, x);
        } else {
            int u, v;
            cin >> u >> v;
            cout << get(u, v) << '\n';
        }
    }

    return 0;
}

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

PS

Не судите строго, это мой первый пост на подобные темы. Если где-то заметите опечатку, прошу сообщить.

Хотелось бы сказать спасибо моим друзьям, которые помогли найти хоть какую-то информацию о данной модификации.

Кажется, что на данную структуру можно обобщить массовые операции, т.к она очень похожа на дерево отрезков снизу (но сейчас 2 часа ночи и как-то не хочется об этом думать).