[BJOI2017]树的难题

Description
给你一棵 n 个点的无根树。树上的每条边具有颜色。 一共有 m 种颜色，编号为 1 到 m。第 i 种颜色的权值为 ci。对于一条树上的简单路径，路径上经过的所有边按顺序组成一个颜色序列，序列可以划分成若干个相同颜色段。 定义路径权值为颜色序列上每个同颜色段的颜色权值之和。请你计算，经过边数在 l 到 r 之间的所有简单路径中， 路径权值的最大值。

Input
第一行， 四个整数 n, m, l, r。
第二行， n 个整数 c1, c2, ……, cm，由空格隔开。依次表示每个颜色的权值。
接下来 n-1 行，每行三个整数 u, v, c，表示点 u 和点 v 之间有一条颜色为 c 的边。
\(n\leqslant 2*10^5\)
\(m\leqslant n\)

Output
输出一行， 一个整数， 表示答案。

Sample Input
5 3 1 4
-1 -5 -2
1 2 1
1 3 1
2 4 2
2 5 3

Sample Output
-1

HINT
颜色权值均为负，最优路径为 (1, 2) 或 (1, 3)。

---

这种树上balabala的题肯定是要用点分治的，找到分治重心后，由于颜色段的存在，我们肯定是把出边颜色相同的放在一起考虑（考虑的同时显然还要按子树最深深度排序，这都是细节啦）

然后我们维护两个桶，一个记录异色桶信息（\(f[i]\)表示能与\(i\)匹配为合法路径的最大值），一个记录当前同色桶信息（\(g[i]\)表示深度为\(i\)的最大权值）

然后我们枚举子树，得到信息先去查询答案，然后将其扔到对应同色桶中合并信息，当我们枚举到另一种颜色的时候，将同色桶信息合并入异色桶，并且清空同色桶

查询的时候使用单调队列，清空的时候用for循环

时间复杂度为\(O(n\log n)\)

/*program from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define inf 0x3f3f3f3f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
inline char gc(){
	static char buf[1000000],*p1=buf,*p2=buf;
	return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int frd(){
	int x=0,f=1; char ch=gc();
	for (;ch<'0'||ch>'9';ch=gc())	if (ch=='-')	f=-1;
	for (;ch>='0'&&ch<='9';ch=gc())	x=(x<<3)+(x<<1)+ch-'0';
	return x*f;
}
inline int read(){
	int x=0,f=1; char ch=getchar();
	for (;ch<'0'||ch>'9';ch=getchar())	if (ch=='-')	f=-1;
	for (;ch>='0'&&ch<='9';ch=getchar())	x=(x<<3)+(x<<1)+ch-'0';
	return x*f;
}
inline void print(int x){
	if (x<0)	putchar('-'),x=-x;
	if (x>9)	print(x/10);
	putchar(x%10+'0');
}
const int N=2e5;
int pre[(N<<1)+10],now[N+10],child[(N<<1)+10],val[(N<<1)+10];
int size[N+10],VC[N+10];//value of color
bool vis[N+10];
int tot,root,Max,Ans;
int n,m,L,R;
inline void join(int x,int y,int z){pre[++tot]=now[x],now[x]=tot,child[tot]=y,val[tot]=z;}
inline void insert(int x,int y,int z){join(x,y,z),join(y,x,z);}
inline void Get_root(int x,int fa,int sz){
	int res=0; size[x]=1;
	for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
		if (son==fa||vis[son])	continue;
		Get_root(son,x,sz);
		size[x]+=size[son];
		res=max(res,size[son]);
	}
	res=max(res,sz-size[x]);
	if (res<Max)	Max=res,root=x;
}
int Df[N+10],C_D[N+10];//Df:deepest; C_D:color of deepest
inline void Get_Df(int x,int fa,int D){
	Df[x]=D;
	for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
		if (son==fa||vis[son])	continue;
		Get_Df(son,x,D+1);
		Df[x]=max(Df[x],Df[son]);
	}
}
int Dv[N+10];//deep value
inline void get_Dv(int x,int fa,int v,int Line,int Deep){
	if (Deep>R)	return;
	Dv[Deep]=max(Dv[Deep],v);
	for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
		if (son==fa||vis[son])	continue;
		get_Dv(son,x,v+(val[p]!=Line)*VC[val[p]],val[p],Deep+1);
	}
}
inline void merge(int *a,int &la,int *b,int &lb){for (int i=1;i<=max(la,lb);++i)	a[i]=max(a[i],b[i]),b[i]=-inf;	la=lb;}
int T[N+10];//T[i] means the max{f[j]} and i+j in [L,R]
int solve(int *a,int la,int *b,int lb,int v,bool flag){
	la=min(la,R),lb=min(lb,R);
	static int h[N+10]; int head=1,tail=0,res=-inf;
	for (int i=lb,j=0;i;i--){
		while (j<=la&&j+i<=R){
			while (head<=tail&&a[h[tail]]<=a[j])	tail--;
			h[++tail]=j++;
		}
		while (head<=tail&&h[head]+i<L)	head++;
		if (flag)	res=max(res,T[i]+b[i]);
		if (head<=tail&&h[head]+i<=R&&h[head]+i>=L)
			flag?res=max(res,a[h[head]]-v+b[i]):b[i]=a[h[head]];
	}
	return res;
}
struct S1{
	int Col,Deep,x;
	inline void insert(int _Col,int _Deep,int _x){Col=_Col,Deep=_Deep,x=_x;}
	bool operator <(const S1 &tis)const{return Col!=tis.Col?C_D[Col]<C_D[tis.Col]:Deep<tis.Deep;}
}A[N+10];
int f[N+10],g[N+10];//f:different color value; g:same color value
inline void divide(int x){
	vis[x]=1; int son_sz=0;//num of son
	for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
		if (vis[son])	continue;
		Get_Df(son,0,1),C_D[val[p]]=max(C_D[val[p]],Df[son]);
		A[++son_sz].insert(val[p],Df[son],son);
	}
	sort(A+1,A+1+son_sz);
	if (A[son_sz].Deep<<1<L)	return;
	int sz_f=0,sz_g=0;//size of f & g
	for (int i=1;i<=son_sz;++i){
		if (i!=1&&A[i].Col!=A[i-1].Col){
			merge(f,sz_f,g,sz_g),sz_g=0;
			solve(f,sz_f,T,C_D[A[i].Col],0,false);
		}
		get_Dv(A[i].x,0,VC[A[i].Col],A[i].Col,1);
		Ans=max(Ans,solve(g,sz_g,Dv,A[i].Deep,VC[A[i].Col],true));
		merge(g,sz_g,Dv,A[i].Deep);
	}
	for (int i=1;i<=son_sz;++i)	C_D[A[i].Col]=0;
	for (int i=1;i<=A[son_sz].Deep;++i){
		f[i]=g[i]=-inf;
		T[i]=(L<=i&&i<=R)?0:-inf;
	}
	for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){
		if (vis[son])	continue;
		Max=inf,root=0;
		Get_root(son,0,size[son]);
		divide(root);
	}
}
int main(){
	n=frd(),m=frd(),L=frd(),R=frd();
	for (int i=1;i<=m;++i)	VC[i]=frd();
	for (int i=1;i<n;++i){
		int x=frd(),y=frd(),z=frd();
		insert(x,y,z);
		f[i]=g[i]=T[i]=Dv[i]=-inf;
	}
	f[n]=g[n]=T[n]=Dv[n]=Ans=-inf;
	Max=inf,root=0;
	Get_root(1,0,n);
	divide(root);
	printf("%d\n",Ans);
	return 0;
}