【POJ1330】Nearest Common Ancestors(LCA)

记录一个菜逼的成长。。

推荐参考解释：http://hihocoder.com/contest/hiho15/problem/1
LCA模板题
一、基于tarjan的离线算法

#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
#define cl(a,b) memset(a,b,sizeof(a))
const int maxn = 10000 + 10;
struct Edge{
    int to,next;
}edge[maxn];
int head[maxn],cnt;
int pre[maxn];
int vis[maxn],n,ancestor[maxn];
vector<int>query[maxn];
int d[maxn];
void add(int u,int v)
{
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
int findr(int x)
{
    return pre[x] == x ? x : pre[x] = findr(pre[x]);
}
void unio(int x,int y)
{
    int fx = findr(x),fy = findr(y);
    if(fx != fy)pre[fy] = fx;
}
void init()
{
    cl(head,-1),cl(vis,0);
    cl(ancestor,-1),cl(d,0);
    cnt = 0;
    for( int i = 1; i <= n; i++ )
        pre[i] = i,query[i].clear();

}
void tarjan(int u)
{
    for( int i = head[u]; ~i; i = edge[i].next ){
        int v = edge[i].to;
        tarjan(v);
        unio(u,v);
    }
    vis[u] = 1;
    for( int i = 0; i < query[u].size(); i++ ){
        if(vis[query[u][i]]){
            ancestor[u] = findr(query[u][i]);
        }
    }

}
int main()
{
    int T;scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        init();
        for( int u,v,i = 0; i < n-1; i++ ){
            scanf("%d%d",&u,&v);
            add(u,v);
            d[v]++;
        }
        int a,b;
        scanf("%d%d",&a,&b);
        query[a].push_back(b);
        query[b].push_back(a);
        for( int i = 1; i <= n; i++ ){
            if(!d[i]){
                tarjan(i);
                break;
            }
        }
        printf("%d\n",ancestor[a] != -1 ? ancestor[a] : ancestor[b]);
    }
    return 0;
}

二、基于DFS+ST的在线算法

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <deque>
#include <cctype>
#include <bitset>
#include <cmath>
#include <cassert>
using namespace std;
#define ALL(v) (v).begin(),(v).end()
#define cl(a,b) memset(a,b,sizeof(a))
#define bp __builtin_popcount
#define pb push_back
#define mp make_pair
#define fin freopen("D://in.txt","r",stdin)
#define fout freopen("D://out.txt","w",stdout)
#define lson t<<1,l,mid
#define rson t<<1|1,mid+1,r
#define seglen (node[t].r-node[t].l+1)
#define pi 3.1415926
#define exp  2.718281828459
#define lowbit(x) (x)&(-x)
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> PII;
typedef pair<LL,LL> PLL;
typedef vector<PII> VPII;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
template <typename T>
inline void read(T &x){
    T ans=0;
    char last=' ',ch=getchar();
    while(ch<'0' || ch>'9')last=ch,ch=getchar();
    while(ch>='0' && ch<='9')ans=ans*10+ch-'0',ch=getchar();
    if(last=='-')ans=-ans;
    x = ans;
}
/***********LCA-ST online***************/
const int maxn = 30000 + 10;
PII dp[maxn][30];
struct Edge{
    int to,next;
}edge[maxn];
int head[maxn],cnt,n;
int d[maxn];///计算入度
///a[i] = j := dfs的序列号,编号为i的点的序列号为j
///first[i] = j := 编号为i的点第一次出现的序列号为j
///depth[i] = j := 序列号为i的深度为j
int a[maxn*2],ind,first[maxn],depth[maxn*2];
void add(int u,int v)
{
    edge[cnt].to = v;
    edge[cnt].next = head[u];
    head[u] = cnt++;
}
void dfs(int x,int dep)
{
    first[x] = ind;
    depth[ind] = dep;
    a[ind++] = x;
    for( int i = head[x]; ~i; i = edge[i].next ){
        int v = edge[i].to;
        dfs(v,dep+1);
        depth[ind] = dep;
        a[ind++] = x;
    }
}
void ST(int n)
{
    for( int i = 0; i < n; i++ )        ///下标从0开始
    ///first 为深度  second 为 序列号即下标
        dp[i][0].first = depth[i],dp[i][0].second = i;
    for( int j = 1; (1 << j) <= n; j++ ){
        for( int i = 0; i + (1 << j) - 1 < n; i++ ){
            if(dp[i][j-1].first < dp[i+(1<<j-1)][j-1].first){
                dp[i][j].first = dp[i][j-1].first;
                dp[i][j].second = dp[i][j-1].second;
            }
            else {
                dp[i][j].first = dp[i+(1<<j-1)][j-1].first;
                dp[i][j].second = dp[i+(1<<j-1)][j-1].second;
            }
        }
    }
}
int query(int u,int v)
{
    if(first[u] > first[v])swap(u,v);
    int w = first[v] - first[u] + 1;
    int k = (int)(log(w*1.0) / log(2.0));
    return dp[first[u]][k].first < dp[first[v]-(1<<k)+1][k].first ? dp[first[u]][k].second : dp[first[v]-(1<<k)+1][k].second;
}
void init()
{
    cl(head,-1);
    cl(d,0);
    cl(first,-1);
    cl(depth,-1);
    cnt = ind = 0;
}
int main()
{
    int T;scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        init();
        for( int u,v,i = 1; i < n; i++ ){
            scanf("%d%d",&u,&v);
            add(u,v);
            d[v]++;
        }
        for( int i = 1; i <= n; i++ ){
            if(!d[i]){
                dfs(i,0);
                break;
            }
        }
        ST(ind);
        int u,v;
        scanf("%d%d",&u,&v);
        int res = query(u,v);
        printf("%d\n",a[res]);
    }
    return 0;
}