银河战舰 [启发式合并+dp]

题面

思路

我们首先考虑传统的链上LIS做法：保存每个长度的LIS末端的最小值，二分查找

那么这道题其实就只是搬到树上来做了而已

我们考虑一个节点，假设它的儿子已经处理完毕了

那么我们选择LIS最长的儿子进行继承，然后每次和其它儿子合并

合并的方法就是逐位取min值

合并完了以后再把当前节点二分一下加进去

记录的LIS，因为本题中的路径可以往根走也可以往叶子走，所以我们要记录从根开始的LIS和从叶子开始的LIS（其实就是从根开始的LDS），维护方法是一样的

然后对于答案的统计，有三种情况：

以当前节点为一端，向下递增

以当前节点为一端，向下递减

以当前子树中某一个点为一端，经过当前点，进入当前子树另一个点

前两种直接算就好了，第三种可以枚举LIS的长度，在LDS数组上面二分

合并的时候用启发式合并，这样总复杂度是$O(n\log^2 n)$

Code

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cassert>
#include<vector>
using namespace std;
inline int read(){
	int re=0,flag=1;char ch=getchar();
	while(!isdigit(ch)){
		if(ch=='-') flag=-1;
		ch=getchar();
	}
	while(isdigit(ch)) re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
	return re*flag;
}
int n,a[200010],dep[200010],cnte,ans=0;
int first[200010];
vector<int>f[200010],g[200010];
struct edge{
	int to,next;
}e[400010];
inline void add(int u,int v){
	e[++cnte]=(edge){v,first[u]};first[u]=cnte;
	e[++cnte]=(edge){u,first[v]};first[v]=cnte;
}
bool anti(int l,int r){return l>r;}
void fg(int u,int v){
	int i,pos,su=f[u].size(),sv=g[v].size();
	if(su<sv){
		for(i=0;i<su;i++){
			pos=lower_bound(g[v].begin(),g[v].end(),f[u][i],anti)-g[v].begin();
			ans=max(ans,i+1+pos);
		}
	}
	else{
		for(i=0;i<sv;i++){
			pos=lower_bound(f[u].begin(),f[u].end(),g[v][i])-f[u].begin();
			ans=max(ans,i+1+pos);
		}
	}
}
void only(int u,int v){
	int l1,l2;
	l1=lower_bound(f[u].begin(),f[u].end(),a[u])-f[u].begin();
	l2=lower_bound(g[v].begin(),g[v].end(),a[u],anti)-g[v].begin();
	ans=max(ans,l1+l2+1);
	l1=lower_bound(f[v].begin(),f[v].end(),a[u])-f[v].begin();
	l2=lower_bound(g[u].begin(),g[u].end(),a[u],anti)-g[u].begin();
	ans=max(ans,l1+l2+1);
}
void merge(int u,int v){
	int i,su,sv;
	su=f[u].size();sv=f[v].size();
	if(su>=sv) for(i=0;i<sv;i++) f[u][i]=min(f[u][i],f[v][i]);
	else{
		for(i=0;i<su;i++) f[v][i]=min(f[u][i],f[v][i]);
		swap(f[u],f[v]);
	}
	su=g[u].size();sv=g[v].size();
	if(su>=sv) for(i=0;i<sv;i++) g[u][i]=max(g[u][i],g[v][i]);
	else{
		for(i=0;i<su;i++) g[v][i]=max(g[u][i],g[v][i]);
		swap(g[u],g[v]);
	}
}
void join(int u){
	int len,pos;
	len=f[u].size();
	pos=upper_bound(f[u].begin(),f[u].end(),a[u])-f[u].begin();
	if(!len||!pos||a[u]>f[u][pos-1]){
		if(pos==len) f[u].push_back(a[u]);
		else f[u][pos]=a[u];
	}
	len=g[u].size();
	pos=upper_bound(g[u].begin(),g[u].end(),a[u],anti)-g[u].begin();
	if(!len||!pos||a[u]<g[u][pos-1]){
		if(pos==len) g[u].push_back(a[u]);
		else g[u][pos]=a[u];
	}
}
void dfs(int u,int f){
	int i,v;
	for(i=first[u];~i;i=e[i].next){
		v=e[i].to;if(v==f) continue;
		dfs(v,u);
		only(u,v);
		fg(u,v);fg(v,u);
		merge(u,v);
	}
	join(u);
}
int main(){
	memset(first,-1,sizeof(first));
	n=read();int i,t1,t2;
	for(i=1;i<=n;i++) a[i]=read();
	for(i=1;i<n;i++){
		t1=read();t2=read();
		add(t1,t2);
	}
	dfs(1,0);
	printf("%d\n",ans);
}