BZOJ4860 BJOI2017 树的难题 点分治、线段树合并

传送门

---

只会线段树……关于单调队列的解法可以去看“重建计划”一题。

看到路径长度$\in [L,R]$考虑点分治。可以知道，在当前分治中心向其他点的路径中，始边（也就是分治中心到对应子树的根的那一条边）颜色相同的两条路径在拼合的时候在加上两条路径的权值之后需要减掉始边颜色的权值（因为被计算了两次），而初始边颜色不同的进行拼合就直接将两条路径的权值加起来即可。我们考虑分开维护这两种拼合。

在每一个分治中心里，我们对其引出的边按照颜色排序（目的是使得始边颜色相同的若干子树放在一起统一遍历），维护两个线段树，一个维护之前遍历过的子树中初始边颜色与当前子树不同的子树中每种长度的路径的最大权值，另一个维护之前遍历过的子树中初始边颜色与当前子树相同的子树中每种长度的路径的最大权值。

那么我们每一次遍历完一棵子树，在线段树中对于每一种长度的路径在线段树上查询可以拼合的长度的路径的最大权值，记得在第二个线段树中询问到的答案需要减去始边颜色的权值，然后用这一棵子树的路径更新第二个线段树。每一次遍历完一种颜色就把第二个线段树合并到第一个线段树内即可。复杂度$O(nlog^2n)$

 #include<bits/stdc++.h>
 #define INF 0x7fffffff
 #define int long long
 #define mid ((l + r) >> 1)
 //This code is written by Itst
 using namespace std;

 inline int read(){
     int a = ;
     bool f = ;
     char c = getchar();
     while(c != EOF && !isdigit(c)){
         if(c == '-')
             f = ;
         c = getchar();
     }
     while(c != EOF && isdigit(c)){
         a = (a << ) + (a << ) + (c ^ '');
         c = getchar();
     }
     return f ? -a : a;
 }

 const int MAXN = ;
 vector < pair < int , int > > Edge[MAXN];
 struct node{
     int l , r , maxN;
 }Tree[MAXN * ];
 int N , M , L , R , ans , cntNode , nowSize , minSize , minInd , roota , rootb;
 int val[MAXN] , size[MAXN] , sz[MAXN] , mx[MAXN];
 bool vis[MAXN];

 inline int allocate(){
     int t = ++cntNode;
     Tree[t].l = Tree[t].r = ;
     Tree[t].maxN = -INF;
     return t;
 }

 inline void pushup(int x){
     Tree[x].maxN = max(Tree[Tree[x].l].maxN , Tree[Tree[x].r].maxN);
 }

 inline int max(int a , int b){
     return a > b ? a : b;
 }

 int merge(int p , int q){
     if(!p)
         return q;
     if(!q)
         return p;
     Tree[p].maxN = max(Tree[p].maxN , Tree[q].maxN);
     Tree[p].l = merge(Tree[p].l , Tree[q].l);
     Tree[p].r = merge(Tree[p].r , Tree[q].r);
     return p;
 }

 void insert(int& now , int l , int r , int tar , int num){
     if(!now)
         now = allocate();
     if(l == r)
         Tree[now].maxN = max(Tree[now].maxN , num);
     else{
         if(mid >= tar)
             insert(Tree[now].l , l , mid , tar , num);
         else
             insert(Tree[now].r , mid +  , r , tar , num);
         pushup(now);
     }
 }

 int query(int now , int l , int r , int L , int R){
     if(l >= L && r <= R)
         return Tree[now].maxN;
     if(!now)
         return -INF;
     int maxN = -INF;
     if(mid >= L)
         maxN = max(maxN , query(Tree[now].l , l , mid , L , R));
     if(mid < R)
         maxN = max(maxN , query(Tree[now].r , mid +  , r , L , R));
     return maxN;
 }

 void getSize(int x){
     vis[x] = ;
     ++nowSize;
     for(int i =  ; i < sz[x] ; ++i){
         int t = Edge[x][i].second;
         if(!vis[t])
             getSize(t);
     }
     vis[x] = ;
 }

 void getRoot(int x){
     size[x] = vis[x] = ;
     int maxN = ;
     for(int i =  ; i < sz[x] ; ++i){
         int t = Edge[x][i].second;
         if(!vis[t]){
             getRoot(t);
             size[x] += size[t];
             maxN = max(maxN , size[t]);
         }
     }
     maxN = max(maxN , nowSize - size[x]);
     if(maxN < minSize){
         minSize = maxN;
         minInd = x;
     }
     vis[x] = ;
 }

 void dfs(int x , int c , int len , int nowCol){
     if(len > R)
         return;
     vis[x] = ;
     mx[len] = max(mx[len] , c);
     for(int i =  ; i < sz[x] ; ++i){
         int t = Edge[x][i].second;
         if(!vis[t])
             dfs(Edge[x][i].second , nowCol == Edge[x][i].first ? c : c + val[Edge[x][i].first] , len +  , Edge[x][i].first);
     }
     vis[x] = ;
 }

 void solve(int x){
     nowSize = cntNode = roota = rootb = ;
     minSize = INF;
     getSize(x);
     getRoot(x);
     int root = minInd;
     getSize(root);
     vis[root] = ;
     for(int i =  ; i < sz[root] ; ++i){
         int t = Edge[root][i].second , r = Edge[root][i].first;
         if(!vis[t]){
             memset(mx , -0x3f , sizeof(int) * (size[t] + ));
             if(rootb && r != Edge[root][i - ].first){
                 roota = merge(roota , rootb);
                 rootb = ;
             }
             dfs(t , val[r] ,  , r);
             for(int i =  ; i <= size[t] && i < R && mx[i] != mx[] ; ++i)
                 ans = max(max(ans , i >= L && i <= R ? mx[i] : -INF) , max(query(roota ,  , R , max( , L - i) , R - i) , query(rootb ,  , R , max( , L - i) , R - i) - val[r]) + mx[i]);
             ans = max(ans , mx[R]);
             for(int i =  ; i <= size[t] && i < R && mx[i] != mx[] ; ++i)
                 insert(rootb ,  , R , i , mx[i]);
         }
     }
     for(int i =  ; i < sz[root] ; ++i){
         int t = Edge[root][i].second;
         if(!vis[t])
             solve(t);
     }
 }

 signed main(){
 #ifndef ONLINE_JUDGE
     freopen("3714.in" , "r" , stdin);
     //freopen("3714.out" , "w" , stdout);
 #endif
     Tree[].maxN = ans = -INF;
     N = read();
     M = read();
     L = read();
     R = read();
     for(int i =  ; i <= M ; ++i)
         val[i] = read();
     for(int i =  ; i < N ; ++i){
         int a = read() , b = read() , c = read();
         Edge[a].push_back(make_pair(c , b));
         Edge[b].push_back(make_pair(c , a));
         ++sz[a];
         ++sz[b];
     }
     for(int i =  ; i <= N ; ++i)
         sort(Edge[i].begin() , Edge[i].end());
     solve();
     cout << ans;
     return ;
 }