POJ 1330 Nearest Common Ancestors （LAC）

最新推荐文章于 2019-08-08 19:08:29 发布

原创最新推荐文章于 2019-08-08 19:08:29 发布 · 325 阅读

1 ·

CC 4.0 BY-SA版权

算法同时被 3 个专栏收录

67 篇文章

订阅专栏

POJ

27 篇文章

订阅专栏

LCA

1 篇文章

订阅专栏

本文介绍了一种将Lowest Common Ancestor (LCA) 查询转换为Range Minimum Query (RMQ) 的在线算法实现，通过欧拉序列和线段树结构，实现了快速的 LCA 查询效率提升。

LCA转RMQ 在线算法，，，

//#pragma commmpnt(linkmpr, "/STACK:102400000,102400000")
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <queue>
using namespace std;
typedef long long LL;
const int M = 100010;
const int INF =0x3f3f3f3f;
const int MAXN = 10010;
int rmq[2*MAXN];//rmq数组，就是欧拉序列对应的深度序列

struct ST
{
    int mm[2*MAXN];
    int dp[2*MAXN][20];//最小值对应的下标

    void init(int n)
    {
        mm[0] = -1;
        for(int i = 1; i <= n; i++)
        {
            mm[i] = ((i&(i-1)) == 0)?mm[i-1]+1:mm[i-1];
            dp[i][0] = i;
        }
        for(int j = 1; j <= mm[n]; j++)
            for(int i = 1; i + (1<<j) - 1 <= n; i++)
                dp[i][j] = rmq[dp[i][j-1]] < rmq[dp[i+(1<<(j-1))][j-1]]?dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
    }
    int query(int a,int b)//查询[a,b]之间最小值的下标
    {
        if(a > b)swap(a,b);
        int k = mm[b-a+1];
        return rmq[dp[a][k]] <= rmq[dp[b-(1<<k)+1][k]]?dp[a][k]:dp[b-(1<<k)+1][k];
    }
};
//边的结构体定义
struct Edge
{
    int to,next;
};
Edge edge[MAXN*2];

int tot,head[MAXN];
int F[MAXN*2];//欧拉序列，就是dfs遍历的顺序，长度为2*n-1,下标从1开始
int P[MAXN];//P[i]表示点i在F中第一次出现的位置
int cnt;
ST st;

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

void addedge(int u,int v)//加边，无向边需要加两次
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    head[u] = tot++;
}

void dfs(int u,int fa,int dep)
{
    F[++cnt] = u;
    rmq[cnt] = dep;
    P[u] = cnt;
    for(int i = head[u]; i != -1; i = edge[i].next)
    {
        int v = edge[i].to;
        if(v == fa)continue;
        dfs(v,u,dep+1);
        F[++cnt] = u;
        rmq[cnt] = dep;
    }
}

void LCA_init(int root,int node_num)//查询LCA前的初始化
{
    cnt = 0;
    dfs(root,root,0);
    st.init(2*node_num-1);
}

int query_lca(int u,int v)//查询u,v的lca编号
{
    return F[st.query(P[u],P[v])];
}

bool flag[MAXN];

int main()
{
    int T;
    int N;
    int u,v;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&N);
        init();
        memset(flag,false,sizeof(flag));
        for(int i = 1; i < N; i++)
        {
            scanf("%d%d",&u,&v);
            addedge(u,v);

            addedge(v,u);
            flag[v] = true;
        }
        int root;
        for(int i = 1; i <= N; i++)    //找根
            if(!flag[i])
            {
                root = i;
                break;
            }
        LCA_init(root,N);
        scanf("%d%d",&u,&v);
        printf("%d\n",query_lca(u,v));

    }

    return 0;

}