银河战舰 [启发式合并+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);
}

转载于:https://www.cnblogs.com/dedicatus545/p/9724512.html