UVALive 7148 LRIP

LRIP
Time Limit: 10000MS Memory Limit: Unknown 64bit IO Format: %lld & %llu

解题：树分治

参考了Oyking大神的解法

我们用map<int,int>维护上升序列，first表示value，second表示长度，按first由小到大，second由大到小排列，因为在val相同的时候，当然是越长越好，但是，Oyking大神说过的冗余上升序列，意思就是在你的值比他小，长度也比它小，那么在拼接那个下降的序列的时候，就会导致极差大，所以可以删除这些没用的。

我们在搜索下降序列的时候，可以对map进行lower_bound，找出极差范围内最大的长度，进行合并即可

 #include <bits/stdc++.h>
 using namespace std;
 const int maxn = ;
 struct arc{
     int to,next;
     arc(int x = ,int y = -){
         to = x;
         next = y;
     }
 }e[maxn<<];
 bool vis[maxn];
 int head[maxn],val[maxn],D,ret,tot;
 int sz[maxn],maxson[maxn];
 map<int,int>up;
 void add(int u,int v){
     e[tot] = arc(v,head[u]);
     head[u] = tot++;
 }
 void dfs(int u,int fa){
     sz[u] = ;
     maxson[u] = ;
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to]) continue;
         dfs(e[i].to,u);
         sz[u] += sz[e[i].to];
         maxson[u] = max(maxson[u],sz[e[i].to]);
     }
 }
 int FindRoot(int sum,int u,int fa){
     int ret = u;
     maxson[u] = max(maxson[u],sum - sz[u]);
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to]) continue;
         int x = FindRoot(sum,e[i].to,u);
         if(maxson[x] < maxson[ret]) ret = x;
     }
     return ret;
 }
 void dfs_down(int u,int fa,int len){
     auto it = up.lower_bound(val[u] - D);
     if(it != up.end()) ret = max(ret,it->second +  + len);
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to] || val[e[i].to] < val[u]) continue;
         dfs_down(e[i].to,u,len + );
     }
 }
 void insert(int val,int len){
     auto x = up.lower_bound(val);
     if(x != up.end() && x->second >= len) return;
     auto ed = up.upper_bound(val);
     auto it = map<int,int>::reverse_iterator(ed);
     while(it != up.rend() && it->second <= len) ++it;
     up.erase(it.base(),ed);
     up[val] = len;
 }
 void dfs_up(int u,int fa,int len){
     insert(val[u],len);
     for(int i = head[u]; ~i; i = e[i].next){
         if(e[i].to == fa || vis[e[i].to] || val[e[i].to] > val[u]) continue;
         dfs_up(e[i].to,u,len + );
     }
 }
 void work(int u,vector<int>&son){
     up.clear();
     up[val[u]] = ;
     for(int v:son){
         if(val[v] >= val[u]) dfs_down(v,,);
         if(val[v] <= val[u]) dfs_up(v,,);
     }
 }
 void solve(int u){
     dfs(u,);
     int root = FindRoot(sz[u],u,);
     vis[root] = true;
     vector<int>son;
     for(int i = head[root]; ~i; i = e[i].next)
         if(!vis[e[i].to]) son.push_back(e[i].to);
     work(root,son);
     reverse(son.begin(),son.end());
     work(root,son);
     for(int i = head[root]; ~i; i = e[i].next)
         if(!vis[e[i].to]) solve(e[i].to);
 }
 int main(){
     int kase,n,u,v,cs = ;
     scanf("%d",&kase);
     while(kase--){
         scanf("%d %d",&n,&D);
         memset(head,-,sizeof head);
         memset(vis,false,sizeof vis);
         tot = ;
         for(int i = ; i <= n; ++i)
             scanf("%d",val + i);
         for(int i = ret = ; i < n; ++i){
             scanf("%d%d",&u,&v);
             add(u,v);
             add(v,u);
         }
         solve();
         printf("Case #%d: %d\n",cs++,ret);
     }
     return ;
 }