2016北京集训测试赛（十七）Problem B: 银河战舰

Solution

好题, 又是长链剖分2333

考虑怎么统计答案, 我场上的思路是统计以一个点作为结尾的最长上升链, 但这显然是很难处理的. 正解的方法是统计以每个点作为折弯点的最长上升链. 具体的内容题解已经写得很详细了, 直接看题解吧:

线性的LIS的经典做法：从左往右扫并维护f[x]表示当前长为x的LIS的最后一个数最小是多少，易证f[x]必定递增，每次新加一个数y，则在f中二分查找最小的x使得f[x]>=y，若找到则将f[x]设为y，否则在f末尾加上y。最后f的长度即为答案。

答案一定是某个点往下的不同子树中的一个最长上升子序列和一个最长下降子序列拼在一起，考虑求出每个点往下的最长单调子序列。先只考虑最长下降子序列，则如果将其从下往上看的话即是一个LIS。对树dfs，每个点u保存一个f[u][x]表示从下往上走到u时长为x的LIS的最后一个数（深度最小）最小是多少。其中对于一个点u，其儿子为v1..vm，如果u本身不在LIS内，则显然f[u][x]=min(f[v][x])，即f[u]=min(f[v])。求出这样的f[u][x]后，将u本身考虑进LIS内只需要和线性LIS一样，在f[u]中二分并插入即可，这里二分的总复杂度由于每一个点都会二分一次，为O(nlgn)。

计算f[u]的方法是将儿子的f一一暴力合并（即取min），即先合并f[v1],f[v2]，再与f[v3]合并，等等。可以发现，由于此时儿子已经更新完毕，所以f[v]均不需要保存，故可以被安全的修改，比如可以将f[v1],f[v2]合并到f[v1]中，再与f[v3]合并到f[v1]中，合并完后直接令f[u]指向f[v1]，不需要新的空间和复制数组的时间。这时，一次暴力合并，如合并f[v1],f[v2]需要的操作次数为f[v1]与f[v2]中短的那个的长度。另外，短的那个数组被合并后，就再也不会被用到，也不会产生其它的时间消耗，相当于这个数组被永久删除了。在这种情况下，由于每一个点最多会往某一个f中插入一个数，共插入最多n个数，而每一次操作均会使某一个f中的一个数被永久删除，故合并的复杂度总共为O(n)。

用相同的方法可以求出每个点往下的LIS，将这个数组设为g，现在考虑如何更新答案。可以发现，只需要在合并时更新答案即可。在将u的儿子v1,v2合并前，需要求出从v1到u到v2（或倒过来，下同不表）的LIS的长度。一种情况是用到u，则在f[v1]和g[v2]中二分u即可，总时间复杂度为O(nlgn)；另一种情况不用到u，则在f[v1]与g[v2]中枚举长度较小的那一个，在另一个中二分即可，这样的操作次数是min(f[v1],g[v2])次二分，如果min(f[v1],g[v2])中小的那个被删除，则这样的总时间复杂度显然为O(nlgn)；而如果其均未被删除，则v1与v2合并后其f,g长度分别为len(f[v1])+1,len(g[v2])+1，则这个节点与其它节点继续合并时，至少会删除一个大小为min(f[v1]+1,g[v2]+1)的数组，故这样的总时间复杂度也为O(nlgn)。故整个算法的复杂度为O(nlgn)。

我好傻啊, 居然没用lower_bound...

#include <cstdio>
#include <cctype>
#include <vector>
#include <algorithm>
#include <cstring>
#define vector std::vector
#define max std::max
#define min std::min

namespace Zeonfai
{
    inline int getInt()
    {
        int a = 0, sgn = 1; char c;
        while(! isdigit(c = getchar())) if(c == '-') sgn *= -1;
        while(isdigit(c)) a = a * 10 + c - '0', c = getchar();
        return a * sgn;
    }
}
const int N = (int)2e5, INF = 2139062143;
int ans = 0;
struct tree
{
    struct node
    {
        vector<int> suc;
        int w, dep, maxDepth, hvy;
    }nd[N + 1];
    inline void addEdge(int u, int v) {nd[u].suc.push_back(v); nd[v].suc.push_back(u);}
    void getSize(int u, int pre)
    {
        nd[u].maxDepth = 1; nd[u].dep = ~ pre ? nd[pre].dep + 1 : 0; nd[u].hvy = -1;
        for(auto v : nd[u].suc) if(v != pre) {getSize(v, u); if(nd[v].maxDepth + 1 > nd[u].maxDepth) nd[u].hvy = v, nd[u].maxDepth = nd[v].maxDepth + 1;}
    }
    void work(int u, int pre, int *LIS, int *LDS)
    {
        if(~ nd[u].hvy) work(nd[u].hvy, u, LIS, LDS);
        int L = 1, R = nd[u].maxDepth, pos;
        while(L <= R)
        {
            int mid = L + R >> 1;
            if(LIS[mid] >= nd[u].w) {pos = mid; R = mid - 1;} else L = mid + 1;
        }
        LIS[pos] = nd[u].w; ans = max(ans, pos);
        L = 1; R = nd[u].maxDepth; pos;
        while(L <= R)
        {
            int mid = L + R >> 1;
            if(LDS[mid] <= nd[u].w) {pos = mid; R = mid - 1;} else L = mid + 1;
        }
        LDS[pos] = nd[u].w; ans = max(ans, pos);
        for(auto v : nd[u].suc) if(v != pre && v != nd[u].hvy)
        {
            int *_LIS = new int[nd[v].maxDepth + 2], *_LDS = new int[nd[v].maxDepth + 2];
            memset(_LIS, 127, (nd[v].maxDepth + 2) << 2); memset(_LDS, 0, (nd[v].maxDepth + 2) << 2); _LIS[0] = 0; _LDS[0] = INF;
            work(v, u, _LIS, _LDS);
            for(int i = 1; i <= nd[v].maxDepth + 1; ++ i)
            {
                int L = 0, R = nd[u].maxDepth;
                while(L <= R)
                {
                    int mid = L + R >> 1;
                    if(LDS[mid] > _LIS[i]) {ans = max(ans, mid + i); L = mid + 1;} else R = mid - 1;
                }
            }
            int L = 0, R = nd[v].maxDepth + 1, pos;
            while(L <= R)
            {
                int mid = L + R >> 1;
                if(_LIS[mid] >= nd[u].w) {pos = mid; R = mid - 1;} else L = mid + 1;
            }
            _LIS[pos] = nd[u].w; ans = max(ans, pos);
            for(int i = 1; i <= nd[v].maxDepth + 1; ++ i)
            {
                int L = 0, R = nd[u].maxDepth;
                while(L <= R)
                {
                    int mid = L + R >> 1;
                    if(LIS[mid] < _LDS[i]) {ans = max(ans, i + mid); L = mid + 1;} else R = mid - 1;
                }
            }
            L = 0; R = nd[v].maxDepth + 1;
            while(L <= R)
            {
                int mid = L + R >> 1;
                if(_LDS[mid] <= nd[u].w) {pos = mid; R = mid - 1;} else L = mid + 1;
            }
            _LDS[pos] = nd[u].w; ans = max(ans, pos);
            for(int i = 1; i <= nd[v].maxDepth + 1; ++ i) LIS[i] = min(LIS[i], _LIS[i]), LDS[i] = max(LDS[i], _LDS[i]);
            delete[] _LIS; delete[] _LDS;
        }
    }
    inline void work()
    {
        getSize(1, -1);
        int *LIS = new int[nd[1].maxDepth + 1], *LDS = new int[nd[1].maxDepth + 1];
        memset(LIS, 127, (nd[1].maxDepth + 1) << 2); memset(LDS, 0, (nd[1].maxDepth + 1) << 2); LIS[0] = 0; LDS[0] = INF;
        work(1, -1, LIS, LDS);
    }
}T;
int main()
{

    #ifndef ONLINE_JUDGE

    freopen("lis.in", "r", stdin);
    freopen("lis.out", "w", stdout);

    #endif

    using namespace Zeonfai;
    int n = getInt();
    for(int i = 1; i <= n; ++ i) T.nd[i].w = getInt();
    for(int i = 1, u, v; i < n; ++ i) u = getInt(), v = getInt(), T.addEdge(u, v);
    T.work();
    printf("%d\n", ans);
}