LCA:(欧拉序)How far away?

How far away?

题意:

就是给你一颗树,再给你m个询问,每一个询问包含了两个节点,问你 left -> right 的距离为多少?
是多组数据…
所以,我RE 了好多次!! 结果又是RMQ打萎了!
又是RMQ打萎了…

思路

(欧拉序+LCA)

欧拉序:

那么首先,我们要知道什么叫欧拉序
我的专业解释:

就是DFS序的一种
什么是DFS序?
就是在DFS 时的顺序
什么是DFS
这……

简单来说这题目有用到欧拉序!

欧拉序专业解释

作用

其实欧拉序有 2 种方法:

1、在每个结点进和出都加进序列。
2、只要到达每一个结点就把他加进序列。

对于第一种欧拉序:

1、求某个点到根节点的额权值和。方法是：需要在进的点处做加法，出的点处做减法，查询某点就只需要查询对应的前缀即可。
*2、求某个子树的权值和。方法是：需要在进的点处做加法，求某个点最后一次出现的位置的前缀和减去第一次出现的位置的前一个位置的前缀和即可。

对于第二种欧拉序

1、求某两点的LCA。显然这两点之间的区间中，深度最小点就是LCA。这可以用RMQ解决。
2、求某个子树的权值和，方法是：只记录第一次出现的数的值，同样的查询某点就只需要查询该点在欧拉序中最后出现的位置的前缀即可减去第一次出现的额位置-1的前缀和即可。

3、换根操作：这种欧拉序相当于以根为起点围着树跑了一圈，那么我们就可以把欧拉序写成一个环就是：
1 　 2 　 3 　 2 　 4 　2 　5 　2 　1 　 6 　7　 6 　 8 　6　 1 　 2　 3 　 2　 4 　 2 　 5 　 2 　 1 　 6 　 7 　 6 　 8 　 6
以某个点为跟的欧拉序就是以某个点在上面的欧拉序中第一次出现的位置为起点向前走（2*n-1）步，例如以4为根的欧拉序就是
1 　2 　 3 　 2 　 4 　2 　 5 　2 　 1 　 6 　 7 　 6 　 8 　 6 　 1 　 2 　 3　 2　 4 　 2 　 5　 2　 1 　 6 　 7 　 6 　 8 　 6
以4为跟的欧拉序，同时可以维护和之类的东西。

比如像这样:

所以经过了这么多的分析,我们会发现可以用第二种欧拉序来解决问题!

思路

所谓的欧拉序就是你每一次搜索到了一个点或者是回溯会来,都进行记录:
所以这个图的欧拉序是这样的:

1   2   3   2   4   2   5   2   1   6   7   6   8   6   1

于是如果我们回求 2 和 6 的祖先的话,我们可以找到第一个2 的位置,这时表示刚好探到了 2 节点,同理于 6 !于是就变成了:

1   **2**   3   2   4   2   5   2   1   **6**   7   6   8   6   1

$所以我们在这一段区间里面找到最小值,因为这一段**表示 2 -- 6 的路径,**那么肯定有$LCA 的存在,并且它只会出现 一次! ,就是这段区间里面的最小值!不难发现—就是 1
而找最小值的工作,我们要交给ST 表来工作!

RMQ

解释ST 表:

dp[i][j]表示从i 开始 的 2^J 的区间里面的最小值是多少
于是可以分为 dp[i][j-1] 与dp[dis][j-1] 的最小(dis 表示 i ~ i+2^j )的中间一段!

方法：ST算法分成两部分：离线预处理 （nlogn）和 在线查询（O(1)）。虽然还可以使用线段树、树状链表等求解区间最值，但是ST算法要比它们更快，而且适用于在线查询。

（1）离线预处理：运用DP思想，用于求解区间最值，并保存到一个二维数组中。

（2）在线查询：对给定区间进行分割，借助该二维数组求最值

代码:

void RMQ()
{
    for(int i=1; i<=cnt; i++) come[i][0]=oula[i];
    for(int j=1; (1<<j)<=cnt; j++)
        for(int i=1; i+(1<<j)-1<=cnt; i++)
        {
            int dis=i+(1<<(j-1));
            come[i][j]=min(come[i][j-1],come[dis][j-1]);
        }
        或者是 come[i][j]=min(come[i][j-1],comr[i+(1<<(j-1))][j-1];
}

代码:

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cstring>
#include <vector>
#define P pair<int,int>
using namespace std;
const int N = 40105;
int T,n,m,cnt,oula[N*10];
int come[N*3][20],len[N*50],vis[N],cost[N];
vector<P> G[N];
void DFS(int root,int father,int num)
{
    oula[++cnt]=root;
    if(vis[root]==-1) vis[root]=cnt;
    for(int i=0; i<G[root].size(); i++)
        if(G[root][i].first!=father)
        {
            if(!cost[G[root][i].first])
                cost[G[root][i].first]=num+G[root][i].second;
            DFS(G[root][i].first,root,num+G[root][i].second);
            oula[++cnt]=root;
        }
}
void RMQ()
{
    for(int i=1; i<=cnt; i++) come[i][0]=oula[i];
    for(int j=1; (1<<j)<=cnt; j++)
        for(int i=1; i+(1<<j)-1<=cnt; i++)
        {
            int dis=i+(1<<(j-1));
            come[i][j]=min(come[i][j-1],come[dis][j-1]);
        }
}
int solve(int l,int r)
{
    int le=len[r-l+1];
    return min(come[r-(1<<le)+1][le],come[l][le]);
}
int main()
{
    int l=0;
    for(int i=1; i<=N*3; i++)
    {
        if((1<<(l+1))<=i) l++;
        len[i]=l;
    }
    scanf("%d",&T);
    for(int loc=1; loc<=T; loc++)
    {
        scanf("%d%d",&n,&m);
        cnt=0;
        memset(vis,-1,sizeof(vis));
        memset(cost,0,sizeof(cost));
        for(int i=1; i<n; i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            G[x].push_back(P(y,z));
            G[y].push_back(P(x,z));
        }
        DFS(1,0,0);
        RMQ();
        for(int i=1; i<=m; i++)
        {
            int x,y;
            scanf("%d%d",&x,&y);
            int left=vis[x],right=vis[y];
            if(left>right) swap(left,right);

            int anc=solve(left,right);
            printf("%d\n",(cost[x]-cost[anc])+abs(cost[anc]-cost[y]));
        }
        for(int i=1; i<=n; i++) G[i].clear();
    }
    return 0;
}