hdu6162 LCA

传送门
题意：给一棵树型图，每个节点代表一个城市，每个节点有一个礼物，售价ci元，问从一个点到另一个点，走最短路，买尽量多的礼物，并且不能买低于l元的也不能买高于r元的礼物，至少准备多少钱。
因为是一棵树，求两个点的最近公共祖先，把路过的点适合来买的礼物的权值加起来就可以了。

#include <set>
#include <map>
#include <stack>
#include <queue>
#include <math.h>
#include <vector>
#include <string>
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <algorithm>

using namespace std;
typedef long long LL;
const LL MAXN = 1e5+5;
const double PI = acos(-1);
const double eps = 1e-8;
const LL MOD = 1e9+7;

struct node
{
    LL to,next;
}edge[MAXN*2];
LL head[MAXN],tot;

void add(LL u,LL v)
{
    edge[tot].to=v;
    edge[tot].next=head[u];
    head[u]=tot++;
}

LL n;
LL val[MAXN];
LL root,min_root;
LL vis[MAXN],son[MAXN],max_son[MAXN];

void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
    memset(vis,0,sizeof(vis));

}
void dfs_size(LL u,LL fa)
{
    LL v;
    son[u]=1;
    max_son[u]=0;
    for(LL i=head[u]; i!=-1; i=edge[i].next)
    {
        v=edge[i].to;
        if(vis[v]||v==fa)
            continue;
        dfs_size(v,u);
        son[u]+=son[v];
        if(max_son[u]<son[v])
            max_son[u]=son[v];
    }
}
void dfs_root(LL r,LL u,LL fa)
{
    LL v;
    max_son[u]=max(max_son[u],son[r]-son[u]);
    if(max_son[u]<min_root)
    {
        min_root=max_son[u];
        root=u;
    }
    for(LL i=head[u]; i!=-1; i=edge[i].next)
    {
        v=edge[i].to;
        if(vis[v]||v==fa)
            continue;
        dfs_root(r,v,u);
    }
}
void solve(LL u)
{
    min_root=n;
    dfs_size(u,-1);
    dfs_root(u,u,-1);
}
LL dep[MAXN],fa[MAXN];
void get_dep(LL u,LL d,LL pre)
{
    LL v;
    dep[u]=d;
    for(LL i=head[u]; i!=-1; i=edge[i].next)
    {
        v=edge[i].to;
        if(v==pre)
            continue;
        fa[v]=u;
        get_dep(v,d+1,u);
    }
}
LL get_sum(LL x,LL y,LL l,LL r)
{
    ///根据深度求解，深度深的向上走，最终使得x y深度相同
    LL ans=0;
    while(dep[x]>dep[y])
    {
        if(val[x]>=l&&val[x]<=r)
            ans+=val[x];
        x=fa[x];
    }
    while(dep[y]>dep[x])
    {
        if(val[y]>=l&&val[y]<=r)
            ans+=val[y];
        y=fa[y];

    }
    ///当两个点相同时说明找到最近公共祖先了。
    while(x!=y)
    {
        if(val[x]>=l&&val[x]<=r)
            ans+=val[x];
        if(val[y]>=l&&val[y]<=r)
            ans+=val[y];
        x=fa[x];
        y=fa[y];
    }
    if(val[x]>=l&&val[x]<=r)
        ans+=val[x];
    return ans;
}
int main()
{
    LL u,v,m;
    while(scanf("%lld%lld",&n,&m)!=-1)
    {
        for(LL i=1; i<=n; i++)
            scanf("%lld",&val[i]);
        init();

        for(LL i=0; i<n-1; i++)
        {
            scanf("%lld%lld",&u,&v);
            add(u,v);
            add(v,u);
        }

        solve(1);///将该树平衡一下，得到重心root
        get_dep(root,1,-1);///从新的根节点root点遍历一下，得到说有点的深度

        LL s,t,l,r;

        for(LL i=0; i<m; i++)
        {
            scanf("%lld%lld%lld%lld",&s,&t,&l,&r);
            if(i==m-1)
                printf("%lld\n",get_sum(s,t,l,r));
            else
                printf("%lld ",get_sum(s,t,l,r));
        }

    }
    return 0;
}