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

本文链接：https://blog.csdn.net/weixin_45630722/article/details/119871796

本文探讨了一种树形结构中求最长上升子序列的问题，并提出了解决方案。首先，通过线段树维护每个节点的最长上升子序列和最长下降子序列，然后针对删除节点的情况，分析了删除树的重心可以达到最小化最长上升子序列长度的效果。通过动态维护和优化，实现了O(n log^2 n)的时间复杂度。最后，给出了完整的AC代码实现。

摘要由CSDN通过智能技术生成

题目大意：

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

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

解题思路：

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

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

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

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

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

在这里插入图片描述

对于拐弯路径我们就再维护一个值就是以 $v a l = p o s$ 结尾的最长下降子序列的长度，对于点 $i$ 的 $val_i$ 我们去查询 $1,val_i-1]$ 里面最长上升子序列的长度 $u l s$ ,我们去查询 $val_i+1,n]$ 里面最长下降子序列的长度 $d l s$ ,路径长度就是 $d l s + u l s + 1$
对于不选择点 $i$ 的情况就是我们直接在 $m e g$ （线段树合并）的时候求解就可以了
每次把两个子树维护的互补区间 $d l s 和 u l s$ 的最大值相加就可以了

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$ ,那么我们先分别求出所有以 $s o n [u]$ 为根的最长上升子序列

但是有 $n$ 个点,每次都是 $O (n l o g (n))$ 求总的就是 $O(n^2log(n))$

优化

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

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

时间就是 $O(nlog^2n)$ 的完美！！！

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;
}