给一颗n个点的有点权的树，有m个询问，对于每个询问u,v,k,首先将点u到点v的最短路径上的所有点按顺序编号，u的编号为1，求树链上所有点的新编号cnt满足cnt%k==0的点的权值的最大值。n,m,k<=10^5
根据k的大小分成两部分处理。原问题可转化为 deep[i] % k = a / b 。
对于k较大的，直接暴力，按照dfs序用一个栈记录下所经过的点，对于每个询问的点不停往上爬。
对于k较小的，将询问按照k分类。对于每一种k，将所有点按照dep[i] % k分类，将每个点树链剖分后hash下来的坐标再按照dep[i] % k映射到一起，用线段树进行维护。
每次查询deep[i] % k = a 时，相当于在某个区间查询最大值。
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <cmath>
#include <ctime>
#include <string>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <iostream>
#include <algorithm>
#pragma comment(linker,"/STACK:102400000,102400000")
using namespace std; #define N 100008
#define LL long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define clr(x,v) memset(x,v,sizeof(x));
#define bitcnt(x) __builtin_popcount(x)
#define rep(x,y,z) for (int x=y;x<=z;x++)
#define repd(x,y,z) for (int x=y;x>=z;x--)
const int mo = ;
const int inf = 0x3f3f3f3f;
const int INF = ;
/**************************************************************************/ int T,n,m,k,sum,block,stop,cq2,tmp,label;
int lt[N],a[N],dep[N],st[N],ans[N],size[N],son[N],rk[N],w[N],top[N],mx[N<<],cl[N],cr[N],fuck[N];;
int f[N][];
struct line{
int u,v,nt;
}eg[N*];
struct que{
int u,v,lca,k,id,flag;
};
vector <que> q1[N],q2[N];
void add(int u,int v){
eg[++sum]=(line){u,v,lt[u]};
lt[u]=sum;
}
void init(){
clr(lt,); clr(ans,);
sum=; tmp=;
}
void dfs(int u,int fa){
f[u][]=fa; dep[u]=dep[fa]+; size[u]=; son[u]=;
for (int i=lt[u];i;i=eg[i].nt){
int v=eg[i].v;
if (v==fa) continue;
dfs(v,u);
size[u]+=size[v];
if (size[v]>size[son[u]]) son[u]=v;
}
}
void dfs_2(int u,int tp){
top[u]=tp; w[u]=++tmp; rk[tmp]=u;
if (son[u]) dfs_2(son[u],tp);
for (int i=lt[u];i;i=eg[i].nt){
int v=eg[i].v;
if (v==f[u][] || v==son[u]) continue;
dfs_2(v,v);
}
}
int lca(int x,int y){
if (dep[x]<dep[y]) swap(x,y);
int d=dep[x]-dep[y];
repd(i,,)
if (d & (<<i)) x=f[x][i];
if (x==y) return x;
repd(i,,)
if (f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
return f[x][];
}
void work_1(int u){
st[++stop]=u;
for (int i=;i<q1[u].size();i++){
int v=q1[u][i].v,x=q1[u][i].lca,k=q1[u][i].k,id=q1[u][i].id,flag=q1[u][i].flag;
if (flag)
{
int tmp=stop-k+;
while (tmp>= && dep[st[tmp]]>=dep[x]){
ans[id]=max(ans[id],a[st[tmp]]);
tmp-=k;
}
}
else
{
int tmp=dep[x]+ k - (dep[v]-dep[x]+) % k ;
while (tmp<=stop && dep[st[tmp]]<=dep[u]){
ans[id]=max(ans[id],a[st[tmp]]);
tmp+=k;
}
}
}
for (int i=lt[u];i;i=eg[i].nt){
int v=eg[i].v;
if (v==f[u][]) continue;
work_1(v);
}
st[stop--]=;
}
int query(int L,int R,int l,int r,int rt){
if (L<=l && r<=R){
return mx[rt];
}
int m=(l+r)>>;
int res=;
if (L <= m) res=max(res,query(L,R,lson));
if (m < R) res=max(res,query(L,R,rson));
return res;
} void build(int l,int r,int rt){
mx[rt]=;
if (l==r){
mx[rt]=a[rk[fuck[l]]];
return;
}
int m=(l+r)>>;
build(lson);
build(rson);
mx[rt]=max(mx[rt<<],mx[rt<<|]);
}
int calc(int L, int R, int k) {
int l = lower_bound(fuck + cl[k], fuck + cr[k] + , L) - fuck;
int r = upper_bound(fuck + cl[k], fuck + cr[k] + , R) - fuck - ;
return l <= r ? query(l,r,,n,) : ;
}
void find(int tp,int x,int cl,int id){
while (top[x]!=top[tp]){
ans[id]=max(ans[id],calc(w[top[x]],w[x],cl));
x=f[top[x]][];
}
ans[id]=max(ans[id],calc(w[tp],w[x],cl));
} vector <int> E[N];
void work_2(int k){
rep(i,,k) E[i].clear();
rep(i,,n) E[(dep[rk[i]]) % k].push_back(i);
label=;
rep(i,,k-){
cl[i]=label+;
for (int j=;j<E[i].size();j++)
fuck[++label]=E[i][j];
cr[i]=label; }
build(,n,);
for (int i=;i<q2[k].size();i++){
int u=q2[k][i].u,v=q2[k][i].v,x=q2[k][i].lca,id=q2[k][i].id;
int tmp1=(dep[x]+(dep[u]-dep[x]+) % k) % k;
int tmp2=(dep[x]+k-(dep[u]-dep[x]+) % k) % k;
find(x,u,tmp1,id);
find(x,v,tmp2,id);
}
}
int main(){
int cas=;
scanf("%d",&T);
while (T--){
printf("Case #%d:\n",++cas );
init();
scanf("%d%d",&n,&m);
rep(i,,n) scanf("%d",&a[i]);
rep(i,,n-){
int u,v;
scanf("%d%d",&u,&v);
add(u,v); add(v,u);
}
dfs(,);
dfs_2(,);
rep(j,,)
rep(i,,n)
f[i][j]=f[f[i][j-]][j-];
block=;
cq2=;
rep(i,,n) q1[i].clear();
rep(i,,n) q2[i].clear();
rep(i,,m){
int u,v,k;
scanf("%d%d%d",&u,&v,&k);
int x=lca(u,v);
if (k>block)
{
q1[u].push_back((que){u,v,x,k,i,});
q1[v].push_back((que){v,u,x,k,i,});
}
else
{
q2[k].push_back((que){u,v,x,k,i,});
}
}
work_1();
rep(i,,block) if (q2[i].size()) work_2(i);
rep(i,,m) printf("%d\n",ans[i]);
}
}