Codeforces Round 279 (Div. 2) F. Treeland Tour（线段树合并）

原题链接：F. Treeland Tour

---

题目大意：

---

给出一棵 $n$ 个点，$n-1$ 条边的树，第 $i$ 个点带点权 $r_i$，让你求出树上 严格 最长上升子序列（$LIS$）的长度。

解题思路：

---

这题的数据范围 $n\le 6000$ ，可以暴力 $O(n^2\log n)$ 过。

这里主要讲讲 $n\le 2\cdot 10^5$ 怎么做。

比如考虑如下的这一棵树，我们现在在 $5$ 号点，且 { 3 , 2 , 8 } \{ 3,2,8\} {3,2,8} 号点为我们的子树，它们的信息在回溯到 $5$ 号点前就已经处理好了。（这里我们简化一下，把点的编号看成点权，但本题点权可以是任意值）

这时候想一下我们的的答案会从哪里来：

• 我们当前的答案直接是我们其中一个子树内的答案。
• 将 其中一个子树 $\to$ 另一个子树 拼起来。
• 将 其中一个子树 $\to$ 根节点 $\to$ 另一个子树 三者拼起来。

先想一想我们怎么把两棵子树拼起来。

比如我们选了绿色子树，和紫色子树拼起来，我们有很多种方法可以选择，但本质上就是从一个子树中选最长上升子序列和另一个子树中选最长下降子序列拼起来。

比如我们选择将绿色子树的上升子序列 { 1 , 3 } \{1,3\} {1,3} 和紫色子树的下降子序列 { 8 , 9 } \{8,9\} {8,9} 拼起来，那么我们的 $LIS$ 长度就是 $2+2=4$ 。

我们要想能将它们拼接起来，前提是最长上升子序列的结尾要比最长下降子序列的开头要小才可以。

这启发我们去做一件事：维护子树中 所有点 作为 $LIS$ 的结尾 和 $LDS$ 的开头，能够获得的最长长度。

我们这里考虑的 所有点 $u$ 作为结尾和开头，指的是考虑点 $u$ 的点权作为结尾和开头。

什么意思呢？比如我们从随便选一个点 $3$ ，我们考虑将它的子树和其他子树拼起来。

如果我们要选出 $3$ 的子树其中一个点为 $LIS$ 的结尾，选的点点权为 $r_u$，那我们就去找其他子树的 $LDS$ 且点权范围在 $[r_u+1,+\infty ]$ 的才合法，而且只需要知道区间 $LDS$ 的$\max$ 值即可。

而且，还只是各个子树内的 $\max$ 值，想到是个 $RMQ$。

假设我们对每个点 $u$ 都开了一棵权值线段树，维护点 $u$ 子树内点 $v$ 的权值 $r_v$ 作为 $LIS$ 的开头，$LDS$ 的结尾 所能得到的最长长度。

比如点 $3$ 开的线段树维护的是整颗绿色子树的信息。我们查询这个线段树点权在 $[3,3]$ 区间内得到的 $LIS$ 值为 2 ( { 1 , 3 } ) 2(\{1,3\}) 2({1,3})，得到的 $LDS$ 值为 2 ( { 3 , 4 } , { 3 , 7 } ) 2(\{3,4\},\{3,7\}) 2({3,4},{3,7})

比如点 $8$ 开的线段树维护的是整颗紫色子树的信息。我们查询这个线段树点权在 $[8,8]$ 区间内得到的 $LIS$ 值为 1 ( { 8 } ) 1(\{8\}) 1({8})，得到的 $LDS$ 值为 2 ( { 8 , 9 } ) 2(\{8,9\}) 2({8,9})

好了，接下来想想怎么拼起来，子树信息和答案的维护才能不重不漏：

• $1.$ 最初时点 $u$ 的线段树里面是空的，所有节点的 $LIS$ 和 $LDS$ 全是 $0$ 。（点 $u$ 可以看成我们当前的 $5$ 号点）
• $2.$ 枚举点 $u$ 的一个子树点 $v$，暴力 $for$ 一遍点 $v$ 线段树的每个区间 $[i,i]$ 查询它的 $LIS,LDS$ 值，同时在点 $u$ 的线段树查 $[-\infty ,i-1]$ 的 $LI{S}^{\prime }$，和 $[i+1,+\infty ]$ 的 $LD{S}^{\prime }$，那么一个合法答案就是 $LIS+LD{S}^{\prime }$ 以及 $LI{S}^{\prime }+LDS$ 。同时，在这一步维护 $u_{[-\infty ,r_u-1]}\to r_u\to v_{[r_u+1,+\infty ]}$ 的 $LIS$ 和 $LDS$ 拼起来再 $+1$ 就是点 $u$ 作为中间节点的合法答案。
• $3.$ 取完答案之后再暴力 $for$ 一遍点 $v$ 线段树的每个区间 $[i,i]$ 查询它的 $LIS,LDS$ 值，然后和点 $u$ 线段树的 $[i,i]$ 的 $LIS,LDS$ 值取 $\max$ ，合并子树线段树的信息。
• $4.$ 将所有子树 $v$ 的线段树都暴力完之后，点 $u$ 中维护的线段树就是点 $u$ 子树中所有点 $v$ 线段树的信息集合的 $\max$ 值，但还不包含点 $u$ 的信息（点 $u$ 的 $LIS$ 和 $LDS$ 还没求出来）。
• $5.$ 再在点 $u$ 的线段树查 $[-\infty ,r_u-1]$ 的 $LI{S}^{\prime }$，和 $[r_u+1,+\infty ]$ 的 $LD{S}^{\prime }$，那么点 $u$ 的 $LIS=LI{S}^{\prime }+1$，$LDS=LD{S}^{\prime }+1$ ，单点更新点 $u$ 线段树 $[r_u,r_u]$ 然后取 $\max$ 即可。

(当然，按照题目的信息来说 $-\infty =1,+\infty =10^6$)

这样，我们的答案维护完的同时，线段树对整颗子树的信息也维护完了。

注意到每个点 $u$ 的信息很少，而且我们在 $2,3$ 的操作本质上等价于跑一个线段树合并，并且合并过程中对答案的实时维护也很简单。

具体上，我们点 $v$ 的线段树要合并到点 $u$ 的线段树。

• 当前合并到的区间是 $[l,r]$，我们求出了一个 $mid=\frac{l+r}{2}$ 。
• 我们的 $v$ 树在 $[l,mid]$ 的 $LIS$ 和 $u$ 树在 $[mid+1,r]$ 的 $LDS$ 合并就是一个合法答案
• 我们的 $u$ 树在 $[l,mid]$ 的 $LIS$ 和 $v$ 树在 $[mid+1,r]$ 的 $LDS$ 合并就是一个合法答案
• 递归合并 $u,v$ 的 $[l,mid]$ 和 $[mid+1,r]$ 节点

这样，我们也可以不重不漏的统计完答案。

于是我们的答案就在如上所有情况中取 $\max$ ，这题就做完了。

时间复杂度：$O(n\log n)$

AC代码：

// LUOGU_RID: 146794873
#include <bits/stdc++.h>
using namespace std;

using PII = pair<int, int>;
using i64 = long long;

const int N = 1e6 + 1, M = 1e7;

struct SegTree {
    int l, r, lis, lds;
} seg[M];

#define lson(k) seg[k].l, l, mid
#define rson(k) seg[k].r, mid + 1, r
#define lis(k) seg[k].lis
#define lds(k) seg[k].lds
#define ls(k) seg[k].l
#define rs(k) seg[k].r

SegTree merge(SegTree& R, const SegTree& A, const SegTree& B) {
    R.lis = max(A.lis, B.lis);
    R.lds = max(A.lds, B.lds);
    return R;
}

int idx = 0;
int creat(int& pre) {
    seg[++idx] = seg[pre];
    return idx;
}

int Modify(int& pre, int l, int r, int& p, int& lis, int& lds) {
    int cur = creat(pre);
    if (l == r) {
        lis(cur) = max(lis(cur), lis);
        lds(cur) = max(lds(cur), lds);
        return cur;
    }
    int mid = l + r >> 1;
    if (p <= mid) {
        ls(cur) = Modify(lson(pre), p, lis, lds);
    } else {
        rs(cur) = Modify(rson(pre), p, lis, lds);
    }
    merge(seg[cur], seg[ls(cur)], seg[rs(cur)]);
    return cur;
}

SegTree Query(int& k, int l, int r, int x, int y) {
    if (!k) return {};
    if (l >= x && r <= y) {
        return seg[k];
    }
    int mid = l + r >> 1; SegTree res;
    if (y <= mid) return Query(lson(k), x, y);
    if (x > mid) return Query(rson(k), x, y);
    return merge(res, Query(lson(k), x, y), Query(rson(k), x, y));
}

int ans = 0;

int Merge(int& pre, int& cur, int l, int r) {
    if (!pre || !cur) return pre + cur;
    if (l == r) {
        lis(cur) = max(lis(cur), lis(pre));
        lds(cur) = max(lds(cur), lds(pre));
        return cur;
    }
    int mid = l + r >> 1;
    ans = max({ ans, lis(ls(pre)) + lds(rs(cur)), lis(ls(cur)) + lds(rs(pre)) });
    ls(cur) = Merge(ls(pre), lson(cur));
    rs(cur) = Merge(rs(pre), rson(cur));
    merge(seg[cur], seg[ls(cur)], seg[rs(cur)]);
    return cur;
}

void solve() {
    int n;
    cin >> n;

    vector<int> val(n + 1);
    for (int i = 1; i <= n; ++i) {
        cin >> val[i];
    }

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

    vector<int> ver(n + 1);
    auto DFS = [&](auto self, int u, int ufa) -> void {
        int ulis = 0, ulds = 0;
        for (auto& v : g[u]) {
            if (v == ufa) continue;
            self(self, v, u);
            int lis = Query(ver[v], 0, N, 0, val[u] - 1).lis;
            int lds = Query(ver[v], 0, N, val[u] + 1, N).lds;

            ans = max({ ans, lis + ulds + 1, ulis + lds + 1 });
            ulis = max(ulis, lis), ulds = max(ulds, lds);
            ver[u] = Merge(ver[v], ver[u], 0, N);
        }
        ver[u] = Modify(ver[u], 0, N, val[u], ++ulis, ++ulds);
    };
    DFS(DFS, 1, 0);

    cout << ans << '\n';
}

signed main() {

    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int t = 1; //cin >> t;
    while (t--) solve();

    return 0;
}