HDU 5052 Yaoge’s maximum profit (树链剖分 + 线段树)

题意：

简单来说，就是求树上从s到t点之间的所有点中后面某点的权值减去前面某点的权值最大差值,并且更新这一段路径

分析：

读完题马上看到树上两点路径就能想到是树链剖分去处理（不会LCT，只好写树剖了T_T），外加线段树区间合并，区间更新去处理权值的更新，关键是查询部分，由于每次查询的两点是有方向的，所以这里需要用一个标记，标记我在向上爬点的时候是从哪个方向到哪个方向，然后再处理结果，细节比较多，重写了一边才过

C++ 不明觉厉TLE G++ 3000ms+

#include
#include
#include
#include

using namespace std;

#define maxn 100004

int val[maxn],cost[maxn];
int son[maxn],fa[maxn],deep[maxn],siz[maxn],top[maxn],pos[maxn],tot;
int fir[maxn],nex[maxn],v[maxn],e_max;

struct node
{
    int l,r;
    long long mxl,mxr,mx,mi,tag;
} t[2*maxn];

template 
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;
}

inline void out(long long x)
{
    if(x>9) out(x/10);
    putchar(x%10+'0');
}


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]]>1;
    init(l,mid,k<<1);
    init(mid+1,r,k<<1|1);
    pushup(k);
}

void update(int d,int l,int r,int k)
{
    if(t[k].l==l&&t[k].r==r)
    {
        t[k].tag+=d;
        t[k].mi+=d;
        t[k].mx+=d;
        return ;
    }
    pushdown(k);
    int mid=t[k].l+t[k].r>>1;
    if(r<=mid) update(d,l,r,k<<1);
    else if(l>mid) update(d,l,r,k<<1|1);
    else update(d,l,mid,k<<1),update(d,mid+1,r,k<<1|1);
    pushup(k);
}

node query(int l,int r,int k)
{
    if(t[k].l==l&&t[k].r==r)
    {
        return t[k];
    }
    pushdown(k);
    int mid=t[k].l+t[k].r>>1;
    if(r<=mid) return query(l,r,k<<1);
    else if(l>mid) return query(l,r,k<<1|1);
    else return Merge(query(l,mid,k<<1),query(mid+1,r,k<<1|1));
}

void check(node& A,node& B)
{
    if(A.mi==0)
    {
        A=B;
        return;
    }
    A.mxl=max(max(A.mxl,B.mxl),A.mx-B.mi);
    A.mxr=max(max(A.mxr,B.mxr),B.mx-A.mi);
    A.mx=max(A.mx,B.mx);
    A.mi=min(A.mi,B.mi);
}

void Query(int s,int t,int c)
{
    int f1=top[s],f2=top[t];
    node ans1,ans2;
    ans1.tag=-1;
    ans1.mxl=ans1.mxr=ans1.mx=ans1.mi=0;
    ans2.tag=1;
    ans2.mxl=ans2.mxr=ans2.mx=ans2.mi=0;
    while(f1!=f2)
    {
        if(deep[f1]deep[t]) swap(s,t),swap(ans1,ans2);
    int tp=ans2.tag;
    node temp=query(pos[s],pos[t],1);
    update(c,pos[s],pos[t],1);
    check(ans2,temp);
    ans2.tag=tp;
    if(ans1.tag==1) swap(ans1,ans2);
    long long ans;
    ans=max(ans1.mxr,ans2.mxl);
    if(ans1.mi) ans=max(ans2.mx-ans1.mi,ans);
    out(ans);
    puts("");
}

int main()
{
    int T;
    scan_d(T);
    while(T--)
    {
        init_();
        int n;
        scan_d(n);
        for(int i=1; i<=n; i++)
        {
            scan_d(cost[i]);
        }
        for(int i=1; i