HDU 3801 Query on a tree(树链剖分离线处理)

题意：

给出一棵树，询问从x点到1点路径上小于等于y的最大值

分析：

建一棵空树，离线处理更新边权和答案

#include<cstring>
#include<string>
#include<iostream>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000");

using namespace std;

#define INF 0x3f3f3f3f
#define maxn 200005

struct node
{
    int x,y;
    int index;
    friend bool operator <(node A,node B)
    {
        return A.y<B.y;
    }
} q[maxn];

int x[maxn],y[maxn],w[maxn],e[maxn];

bool cmp(int x,int y)
{
    return w[x]<w[y];
}

template <class T>
inline bool scan_d(T &ret)
{
    char c;
    int sgn;
    if(c=getchar(),c==EOF) return 0; //EOF
    while(c!='-'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}

int fir[maxn],nex[maxn],v[maxn],e_max;
int son[maxn],top[maxn],fa[maxn],deep[maxn],siz[maxn],in[maxn],tot;
int mx[2*maxn],ans[maxn];

void init_()
{
    memset(son,-1,sizeof son);
    memset(fir,-1,sizeof fir);
    e_max=0;
    tot=1;
}

void add_edge(int s,int t)
{
    int e=e_max++;
    v[e]=t;
    nex[e]=fir[s];
    fir[s]=e;
}

void dfs1(int k,int pre,int d)
{
    deep[k]=d;
    fa[k]=pre;
    siz[k]=1;
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e!=pre)
        {
            dfs1(e,k,d+1);
            siz[k]+=siz[e];
            if(son[k]==-1||siz[son[k]]<siz[e]) son[k]=e;
        }
    }
}

void dfs2(int k,int sp)
{
    top[k]=sp;
    in[k]=tot++;
    if(son[k]==-1) return ;
    dfs2(son[k],sp);
    for(int i=fir[k]; ~i; i=nex[i])
    {
        int e=v[i];
        if(e!=fa[k]&&e!=son[k])
        {
            dfs2(e,e);
        }
    }
}

void init(int l,int r,int k)
{
    mx[k]=-1;
    if(l==r) return ;
    int mid=l+r>>1;
    init(l,mid,k<<1);
    init(mid+1,r,k<<1|1);
}

void update(int val,int s,int l,int r,int k)
{
    if(s==l&&r==l)
    {
        mx[k]=val;
        return ;
    }
    int mid=l+r>>1;
    if(s<=mid) update(val,s,l,mid,k<<1);
    else update(val,s,mid+1,r,k<<1|1);
    mx[k]=max(mx[k<<1],mx[k<<1|1]);
}

int query(int s,int t,int l,int r,int k)
{
    if(l==s&&t==r)
    {
        return mx[k];
    }
    int mid=l+r>>1;
    if(t<=mid) return query(s,t,l,mid,k<<1);
    else if(s>mid) return query(s,t,mid+1,r,k<<1|1);
    else return max(query(s,mid,l,mid,k<<1),query(mid+1,t,mid+1,r,k<<1|1));
}

int Query(int s,int t)
{
    int ans=-1;
    int f1=top[s],f2=top[t];
    while(f1!=f2)
    {
        if(deep[f1]<deep[f2]) swap(f1,f2),swap(s,t);
        ans=max(ans,query(in[f1],in[s],1,tot-1,1));
        s=fa[f1];
        f1=top[s];
    }
    if(s==t) return ans;
    if(deep[s]>deep[t]) swap(s,t);
    ans=max(ans,query(in[s]+1,in[t],1,tot-1,1));
    return ans;
}

int main()
{
    int T;
    scan_d(T);
    while(T--)
    {
        init_();
        int n;
        scan_d(n);
        for(int i=0; i<n-1; i++)
        {
            scan_d(x[i]);
            scan_d(y[i]);
            scan_d(w[i]);
            add_edge(x[i],y[i]);
            add_edge(y[i],x[i]);
            e[i]=i;
        }
        dfs1(1,-1,1);
        dfs2(1,1);
        init(1,tot-1,1);
        sort(e,e+n-1,cmp);
        int pos=0;
        int m;
        scan_d(m);
        for(int i=0; i<m; i++)
        {
            scan_d(q[i].x);
            scan_d(q[i].y);
            q[i].index=i;
        }
        sort(q,q+m);
        for(int i=0; i<m; i++)
        {
            while(pos<n-1&&w[e[pos]]<=q[i].y)
            {
                if(deep[x[e[pos]]]>deep[y[e[pos]]]) swap(x[e[pos]],y[e[pos]]);
                update(w[e[pos]],in[y[e[pos]]],1,tot-1,1);
                pos++;
            }
            ans[q[i].index]=Query(1,q[i].x);
        }
        for(int i=0; i<m; i++)
        {
            printf("%d\n",ans[i]);
        }
    }
    return 0;
}