Codeforces - Gym - 101161 - E - Tax （主席树）

链接：Codeforces - Gym - 101161 - E - Tax
• 给定一棵带权树，每次询问一个路径上所有边权的中位数
• 1 ≤ n ≤ 5* 1e4
• 1 ≤ n ≤ 1e5

这道题可以转化为查询树上一条链的第 $k$ 小。
考虑建主席树，类似求深度的方法建。
然后根据LCA求链上第 $k$ 小即可。

#include<bits/stdc++.h>
using namespace std;
const int N=5e4+7,M=100000;
int n,root[N],tot,sum[N*22],ls[N*22],rs[N*22],d[N];
struct Node
{
    int v,d;
};
vector<Node> adj[N];

namespace LCA
{
    int ord[N<<1],d[N<<1],fir[N],dp[N<<1][20],mm[N<<1],m=0;
    void dfs_lca(int u,int p,int deep)
    {
        ord[++m]=u;
        d[m]=deep;
        fir[u]=m;
        for(int i=0;i<adj[u].size();++i)
        {
            int v=adj[u][i].v;
            if(v==p) continue;
            dfs_lca(v,u,deep+1);
            ord[++m]=u;
            d[m]=deep;
        }
    }
    void init_RMQ()
    {
        mm[0] = -1;
        for(int i=1;i<=m;++i)
        {
            mm[i]= ((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
            dp[i][0]=i;
        }
        for(int j=1;j<=mm[m];++j)
            for(int i=1;i+(1<<j)-1<=m;++i)
            {
                int x=dp[i][j-1],y=dp[i+(1<<(j-1))][j-1];
                dp[i][j]=d[x]<d[y]?x:y;
            }
    }
    int lca(int u,int v)
    {
        u=fir[u],v=fir[v];
        if(u>v) swap(u,v);
        int k=mm[v-u+1];
        int x=dp[u][k],y=dp[v-(1<<k)+1][k];
        return d[x]<d[y]?ord[x]:ord[y];
    }
    void init(int u)
    {
        m=0;
        dfs_lca(u,0,0);
        init_RMQ();
    }
}

void build(int &rt,int l,int r)
{
    rt=++tot;
    sum[rt]=ls[rt]=rs[rt]=0;
    if(l==r) return ;
    int m=(l+r)>>1;
    build(ls[rt],l,m);
    build(rs[rt],m+1,r);
}

void update(int &rt,int last,int l,int r,int p)
{
    rt=++tot;
    ls[rt]=ls[last];
    rs[rt]=rs[last];
    sum[rt]=sum[last]+1;
    if(l==r) return ;
    int m=(l+r)>>1;
    if(p<=m) update(ls[rt],ls[last],l,m,p);
    else update(rs[rt],rs[last],m+1,r,p);
}

void dfs(int u,int p,int deep)
{
    d[u]=deep;
    for(Node e : adj[u])
    {
        int v=e.v,c=e.d;
        if(v==p) continue;
        update(root[v],root[u],1,M,c);
        dfs(v,u,deep+1);
    }
}
int kth(int rt1,int rt2,int rt3,int l,int r,int k)
{
    if(l==r) return l;
    int m=(l+r)>>1;
    int val=sum[ls[rt1]]+sum[ls[rt2]]-2*sum[ls[rt3]];
    if(k<=val) return kth(ls[rt1],ls[rt2],ls[rt3],l,m,k);
    else return kth(rs[rt1],rs[rt2],rs[rt3],m+1,r,k-val);
}
double query(int u,int v)
{
    int lca=LCA::lca(u,v);
    int cnt=d[u]+d[v]-2*d[lca];
    if(cnt&1) return kth(root[u],root[v],root[lca],1,M,cnt/2+1);
    else return (kth(root[u],root[v],root[lca],1,M,cnt/2)+kth(root[u],root[v],root[lca],1,M,cnt/2+1))/(double)2.0;
}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        for(int i=1;i<=n;++i) adj[i].clear();
        for(int i=1;i<n;++i)
        {
            int u,v,d;
            scanf("%d%d%d",&u,&v,&d);
            adj[u].push_back({v,d});
            adj[v].push_back({u,d});
        }
        dfs(1,0,0);
        LCA::init(1);
        int q;
        scanf("%d",&q);
        while(q--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            printf("%.1f\n",query(u,v));
        }
    }
    return 0;
}