（离线树链剖分）HDU

题意：

一颗树，q次查询从u到v路径上所有权值在l到r之间的和。

分析：

一开始想写树上主席树，然后感觉内存不够就放弃。

然后想了一个小时，然后发现，询问似曾相识，回忆起一题。

然后发现直接离线搞就行了。

确切的说这题和HDU4417是完全一样的。

将询问排序，然后把小的点加进去，然后查询。

至于l和r，将两个分开分别处理就行了嘛。

算是比较裸的题了，居然想了这么久。

（哇，后来发现主席树内存是够的。。

可以做，与树链第K大类似，一个数组统计区间内的个数，再开一个longlong保存和即可，

用lca进行二分就行啦。

这样复杂度才nlogn，比树剖快撒。

（哇，比赛的时候同学暴力LCA就A了，而且才700+ms，哇

代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <vector>

using namespace std;

const int maxn=100010;

int n,q,m;

struct Edge
{
    int to,next;
} edge[maxn<<1];
int head[maxn],tot;
int top[maxn];
int fa[maxn];
int deep[maxn];
int num[maxn];
int p[maxn];
int fp[maxn];
int son[maxn];
int pos;

struct P
{
    int val,u;
    bool operator<(const P a)const
    {
        return val<a.val;
    }
};
P val[maxn];


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

void dfs1(int u,int pre,int d)
{
    deep[u]=d;
    fa[u]=pre;
    num[u]=1;
    for(int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if(v!=pre)
        {
            dfs1(v,u,d+1);
            num[u]+=num[v];
            if(son[u]==-1||num[v]>num[son[u]])son[u]=v;
        }
    }
}

void getpos(int u,int sp)
{
    top[u]=sp;
    p[u]=pos++;
    fp[p[u]]=u;
    if(son[u]==-1)return ;
    getpos(son[u],sp);
    for(int i=head[u]; i!=-1; i=edge[i].next)
    {
        int v = edge[i].to;
        if(v!=son[u]&&v!=fa[u])getpos(v,v);
    }
}

struct Node
{
    int left, right;
    long long sum;
} node[maxn<<2];


void build(int n,int left,int right)
{
    node[n].left=left,node[n].right=right;
    node[n].sum=0;
    if(left==right)return ;
    int mid = (left+right)>>1;
    build(n<<1,left,mid);
    build(n<<1|1,mid+1,right);
}

void push_up(int n)
{
    node[n].sum=node[n<<1].sum+node[n<<1|1].sum;
}

void update(int n,int pos,long long val)
{
    if(node[n].left==node[n].right)
    {
        node[n].sum+=val;//wait
        return ;
    }
    int mid = (node[n].left+node[n].right)>>1;
    if(pos<=mid)update(n<<1,pos,val);
    else update(n<<1|1,pos,val);
    push_up(n);
}

long long query(int n,int left,int right)
{
    if(left<=node[n].left&&node[n].right<=right)
    {
        return node[n].sum;
    }
    int mid = (node[n].left+node[n].right)>>1;
    long long sum=0;
    if(mid>=left)sum+=query(n<<1,left,right);
    if(mid<right)sum+=query(n<<1|1,left,right);
    return sum;
}


long long findSum(int x,int y)
{
    long long tmp = 0;
    while(top[x]!=top[y])
    {
        if(deep[top[x]]<deep[top[y]])swap(x,y);
        tmp +=query(1,p[top[x]],p[x]);
        x=fa[top[x]];
    }
    if(deep[x]>deep[y])swap(x,y);
    tmp+=query(1,p[x],p[y]);
    return tmp;
}

struct Q
{
    int u,v,x;
    int i;
};
vector<Q> pl,pr;

bool cmp(Q a,Q b)
{
    return a.x<b.x;
}

long long ansl[maxn],ansr[maxn];


void init()
{
    tot=0;
    memset(head,-1,sizeof(head));
    pos=0;
    memset(son,-1,sizeof(son));
    pl.clear(),pr.clear();
}


int main()
{
    while(~scanf("%d%d",&n,&q))
    {
        init();
        for(int i=1; i<=n; i++)
        {
            scanf("%d",&val[i].val);
            val[i].u=i;
        }
        sort(val+1,val+n+1);
        for(int i=0; i<n-1; i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            addedge(u,v);
            addedge(v,u);
        }
        dfs1(1,0,0);
        getpos(1,1);
        for(int i=0; i<q; i++)
        {
            int u,v,a,b;
            scanf("%d%d%d%d",&u,&v,&a,&b);
            pl.push_back(Q{u,v,a,i});
            pr.push_back(Q{u,v,b,i});
        }
        sort(pl.begin(),pl.end(),cmp);
        sort(pr.begin(),pr.end(),cmp);
        int l = 1;
        build(1,0,pos-1);
        for(int i=0; i<pl.size(); i++)
        {
            while(val[l].val<pl[i].x&&l<=n)
            {
                update(1,p[val[l].u],val[l].val);
                l++;
            }
            ansl[pl[i].i]=findSum(pl[i].u,pl[i].v);
        }
        build(1,0,pos-1);
        l=1;
        for(int i=0; i<pr.size(); i++)
        {
            while(val[l].val<=pr[i].x&&l<=n)
            {
                update(1,p[val[l].u],val[l].val);
                l++;
            }
            ansr[pr[i].i]=findSum(pr[i].u,pr[i].v);
        }
        for(int i=0;i<q-1;i++){
            printf("%lld ",ansr[i]-ansl[i]);
        }
        printf("%lld
",ansr[q-1]-ansl[q-1]);
    }
    return 0;
}