HDU5840 （分块+树链剖分）

Problem This world need more Zhu

题目大意

　　给一颗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]);
     }
 }