线段树合并与分裂维护树上最长上升子序列 + 点分治删点 ---- 2021 牛客多校第一场 C - Cut the tree(详解)

题目大意：

给你一个树，树上每个点都有一个权值$va{l}_{node}$，路径$(u,v)$ 上所有点按顺序有序序列，令$f(u,v)$是这个序列的最长上升子序列的长度，设$G$是$max(f(u,v))|(u,v)是可达的$

现在叫你删除一个点$v$使得$G$最小

---

解题思路：

思路1：求解树最长上升子序列怎么求？

首先我们先假设是对一个有根的树求

1. 对于一个$dp[i]$我们要找到小于$va{l}_i$且最长的子序列去更新$dp[i]$,那么在树上要维护的$va{l}_i$就很多了，对于每个点我们都要开一个线段树，线段树每个叶子节点维护的是以$val=pos$结尾的最长上升子序列的长度是多少？那么我们在遍历的时候自底向上的去合并结果 ---- 线段树合并了
2. 合并接受我们查询$[1,va{l}_i-1]$里面最大的$len$是多少跟新答案

3. 但是有个问题是树上的路径是有拐弯的，而且我们这样子求出来的是一定经过点$i$的，但是我可以路径经过但是点$i$不选呀！!
4. 那么我们还少了两种情况

   4.1：拐弯路径
   4.2：不选点i的情况

5. 对于拐弯路径我们就再维护一个值就是以$val=pos$结尾的最长下降子序列的长度，对于点$i$的$va{l}_i$我们去查询$[1,va{l}_i-1]$里面最长上升子序列的长度$uls$,我们去查询$[va{l}_i+1,n]$里面最长下降子序列的长度$dls$,路径长度就是$dls+uls+1$
6. 对于不选择点$i$的情况就是我们直接在$meg$（线段树合并）的时候求解就可以了
   每次把两个子树维护的互补区间$dls和uls$的最大值相加就可以了

inline int meg(int &x, int y, int l = 1, int r = n) {
   if(!x || !y) {x |= y;return 0;}
   if(l == r) {
      tr[x].uls = max(tr[x].uls, tr[y].uls);
      tr[x].dls = max(tr[x].dls, tr[y].dls);
      return 0;
   }
   int v = max(tr[tr[x].lson].uls + tr[tr[y].rson].dls, 
               tr[tr[y].lson].uls + tr[tr[x].rson].dls);
   //我们知道左右儿子为维护的区间是不交的
   v = max(v,meg(tr[x].lson,tr[y].lson,l,mid));
   v = max(v,meg(tr[x].rson,tr[y].rson,mid+1,r));
   pushup(x);
   return v;
}

---

思路2：如何删点

就是我们知道对于树上路径贪心肯定是删除树的重心！
假如我们现在要删除的点是$u$,那么我们先分别求出所有以$son[u]$为根的最长上升子序列

但是有$n$个点,每次都是$O(nlog(n))$求总的就是$O(n^{2}log(n))$

优化

就是我们假如我们在$it$这个子树里面找到最大值，那么我们只可能去删$it$这个子树里面的点$为了保持平衡很显然$

每次求重心
去找最大的只会递归$log(n)$层

时间就是$O(nlo{g}^{2}n)$的完美！！！

---

AC code

#include <bits/stdc++.h>
#define mid ((l + r) >> 1)
#define Lson rt << 1, l , mid
#define Rson rt << 1|1, mid + 1, r
#define ms(a,al) memset(a,al,sizeof(a))
#define log2(a) log(a)/log(2)
#define lowbit(x) ((-x) & x)
#define IOS std::ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define INF 0x3f3f3f3f
#define LLF 0x3f3f3f3f3f3f3f3f
#define f first
#define s second
#define endl '\n'
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 9;
const int maxn = 100010;
const long double eps = 1e-5;
const int EPS = 500 * 500;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
typedef pair<double,double> PDD;
template<typename T> void read(T &x) {
   x = 0;char ch = getchar();ll f = 1;
   while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
   while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
   read(first);
   read(args...);
}

int n;
struct Segtree {
   int lson, rson;
   int uls, dls;  // 最长上升和下将
}tr[maxn * 64];
int root[maxn], cnt;
int val[maxn];

vector<int> G[maxn];
bool vis[maxn];
int siz[maxn], now_node, mx, rt;
int ans = INF;

void find_root(int u, int fa) {
   siz[u] = 1;
   int max_son = 0;
   for(auto it : G[u]) {
       if(vis[it] || it == fa) continue;
       find_root(it,u);
       siz[u] += siz[it];
       max_son = max(max_son,siz[it]);
   }
   max_son = max(max_son,now_node-siz[u]);
   if(mx > max_son) {
      rt = u;
      mx = max_son;
   }
}
//..............................................................

void pushup(int x) {
   tr[x].uls = max(tr[tr[x].lson].uls, tr[tr[x].rson].uls);
   tr[x].dls = max(tr[tr[x].lson].dls, tr[tr[x].rson].dls);
   return;
}

inline int meg(int &x, int y, int l = 1, int r = n) {
   if(!x || !y) {x |= y;return 0;}
   if(l == r) {
      tr[x].uls = max(tr[x].uls, tr[y].uls);
      tr[x].dls = max(tr[x].dls, tr[y].dls);
      return 0;
   }
   int v = max(tr[tr[x].lson].uls + tr[tr[y].rson].dls, 
               tr[tr[y].lson].uls + tr[tr[x].rson].dls);
   v = max(v,meg(tr[x].lson,tr[y].lson,l,mid));
   v = max(v,meg(tr[x].rson,tr[y].rson,mid+1,r));
   pushup(x);
   return v;
}

inline int quary(int rt, int l, int r, int posl, int posr, bool ok) {
   if(posl > posr) return 0;
   if(posl <= l && posr >= r) {
      if(ok) return tr[rt].dls;
      else return tr[rt].uls;
   }
   int res = 0;
   if(posl <= mid) res = max(quary(tr[rt].lson,l,mid,posl,posr, ok),res);
   if(posr >  mid) res = max(quary(tr[rt].rson,mid+1,r,posl,posr, ok),res);
   return res;
}

void add(int &rt, int l, int r, int pos, int len, bool ok) {
   if(!rt) {
      rt = ++ cnt;
      tr[rt].dls = tr[rt].uls = tr[rt].lson = tr[rt].rson = 0;
   }
   if(l == r) {
      if(ok) tr[rt].dls = max(tr[rt].dls,len);
      else tr[rt].uls = max(tr[rt].uls,len);
      return;
   }

   if(pos <= mid) add(tr[rt].lson,l,mid,pos,len,ok);
   else add(tr[rt].rson,mid+1,r,pos,len,ok);

   pushup(rt);
   return;
}

inline int dfs(int u, int fa) {
   root[u] = 0;
   int _max = 1;
   int maxdls = 0;
   int maxuls = 0;
   for(auto it: G[u]) {
      if(it == fa) continue;
      _max = max(_max,dfs(it,u));
      int todls = quary(root[it],1,n,val[u]+1,n,1);
      int touls = quary(root[it],1,n,1,val[u]-1,0);
      _max = max(todls+maxuls+1,_max);
      _max = max(touls+maxdls+1,_max);
      maxdls = max(maxdls,todls);
      maxuls = max(maxuls,touls);
      _max = max(meg(root[u],root[it]),_max);
   }
   add(root[u],1,n,val[u],maxdls+1,1);
   add(root[u],1,n,val[u],maxuls+1,0);
   return _max;
}

void div(int u) {
   vis[u] = 1;
   int _max = 1;
   int nxt = 0; 
   for(auto it : G[u]) {
      cnt = 0;// 重新开始线段树合并
      int val = dfs(it,u);
      if(val > _max) {
         _max = val;
         nxt = it;
      }
   }

   ans = min(ans,_max);
   if(vis[nxt]) return;

   now_node = siz[nxt]; mx = 1e9;
   find_root(nxt,0);
   div(rt);
}

int main() {
   read(n);
   for(int i = 1; i < n; ++ i) {
      int u, v;
      read(u,v);
      G[u].push_back(v);
      G[v].push_back(u);
   }
   for(int i = 1; i <= n; ++ i) read(val[i]);

   now_node = n; mx = 1e9;
   find_root(1,0);
   div(rt);
   
   cout << ans;
   return 0;
}