LCA的RMQ求法

参考博客

仔细想一想：最近的公共祖先，其实，搜索时回朔，连通这两点，那深度最低肯定是最近的公共祖先啊。

那这样就可以变成RMQ问题了。

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
const int max_=;
int ip,tot;
struct Tree{//树
   int to;
   int next;
   int v;
};
struct Tree a[max_*];
int first[max_];//第一次出现的位置
int edge[max_];//边记录next
int de[max_*];//深度
int id[max_*];//遍历编号（包含回朔）
int dis[max_];//到根的距离。
int dp[max_*][];//st表，记录的是下标
bool vis[max_];//标记数组
void add_edge(int x,int y,int v)//建树
{
    a[++ip].to=y;
    a[ip].v=v;
    a[ip].next=edge[x];
    edge[x]=ip;
}
void dfs(int x,int deep)//dfs遍历
{
    if(vis[x]==)
    {
        first[x]=tot;//记录第一次
        vis[x]=;
    }
    de[tot]=deep,id[tot++]=x;
    for(int i=edge[x];i;i=a[i].next)
    {
        int go_to=a[i].to;
        if(vis[go_to])
            continue;
            int go_v=a[i].v;
            dis[go_to]=dis[x]+go_v;//跟新距离
            dfs(go_to,deep+);
            id[tot]=x,de[tot++]=deep;
    }
}
int Min(int x,int y)//寻找最小深度
{
    if(de[x]>de[y])
        return y;
    else
        return x;
}
void RMQ_ST(int len)
{
    for(int i=;i<len;i++)//初始化
        dp[i][]=i;
    for(int j=;(<<j)<=len;j++)
        for(int i=;i+(<<j)-<len;i++)
    {
        dp[i][j]=Min(dp[i][j-],dp[i+(<<(j-))][j-]);
    }
}
int RMQ_question(int l,int r)
{
    int k=;
    while((<<(k+))<=r-l+)k++;
    return Min(dp[l][k],dp[r-(<<k)+][k]);
}
void itin()
{
    memset(vis,,sizeof(vis));
    memset(dis,,sizeof(dis));
    memset(edge,,sizeof(edge));
    tot=;
    ip=;
}
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        itin();
        int n,m;
        cin>>n>>m;
        for(int i=;i<n-;i++)
        {
            int x,y,v;
            cin>>x>>y>>v;
            add_edge(x,y,v);
            add_edge(y,x,v);
        }
        dfs(,);
        RMQ_ST(tot);
    for(int i=;i<m;i++)
    {
        int u,v,k;
        cin>>u>>v;
        if(first[u]>first[v])//先出现的为左
        {
            k=RMQ_question(first[v],first[u]);
        }
        else
            k=RMQ_question(first[u],first[v]);
        int temp=dis[u]+dis[v]-(*dis[id[k]]);
        cout<<temp<<endl;
            }
}
    return ;
}