hdu 4547 CD操作 LCA倍增算法

题意：给出一棵树之后求两个点的lca。这里用到在线的倍增算法。

主要核心在注释中。

</pre><pre name="code" class="cpp">#include <map>
#include <set>
#include <queue>
#include <stack>
#include <cmath>
#include <time.h>
#include <vector>
#include <cstdio>
#include <string>
#include <iomanip>
///cout << fixed << setprecision(13) << (double) x << endl;
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#define ls rt << 1
#define rs rt << 1 | 1
#define pi acos(-1.0)
#define eps 1e-8
#define Mp(a, b) make_pair(a, b)
#define asd puts("asdasdasdasdasdf");
typedef long long ll;
//typedef __int64 LL;
const int inf = 0x3f3f3f3f;
const int N = 100100;

struct node{
    int v, nxt;
}e[N];
int deg[N], dep[N];
int head[N], cnt;
int n, m;
map <string, int> mp;
int pp;
string s1, s2;
int p[N][30];	//起点i向根走2^j步到达的节点

void init()
{
    memset( deg, 0, sizeof( deg ) );
    memset( head, -1, sizeof( head ) );
    cnt = pp = 0;
    mp.clear();
}

void add( int u, int v )
{
    e[cnt].v = v;
    e[cnt].nxt = head[u];
    head[u] = cnt++;
}

void dfs( int u, int fa )
{
    for( int i = head[u]; ~i; i = e[i].nxt ) {
        int v = e[i].v;
        if( v != fa ) {
            dep[v] = dep[u] + 1;
            dfs( v, u );
        }
    }
}

int LCA( int x, int y )
{
    if( dep[x] < dep[y] ) {
        x ^= y;
        y ^= x;
        x ^= y;
    }
    int dd = dep[x] - dep[y];	//深度之差一定可以用某个二进制表示，那么xy两点就可以通过x向根走先走到同一深度
    for( int i = 0; i <= 25; ++i ) {
        if( dd & (1<<i) )
            x = p[x][i];
    }
    if( x == y )
        return x;
    for( int i = 25; i >= 0; --i ) {	//在同一深度一起向根方向走，设x到lca（x，y）的高度差为z，
					//像上面一样z也可以拆成一个二进制数，就可以按照上面的思路往lca（x，y）走上去了
        if( p[x][i] != p[y][i] ) {
            x = p[x][i];
            y = p[y][i];
        }
    }
    return p[x][0];
}

int main()
{
    cin.sync_with_stdio( false );
    int tot;
    for( cin >> tot; tot--; ) {
        //scanf("%d%d", &n, &m);
        cin >> n >> m;
        init();
        for( int i = 1; i < n; ++i ) {
            cin >> s1 >> s2;
            if( !mp[s1] )
                mp[s1] = ++pp;
            if( !mp[s2] )
                mp[s2] = ++pp;
            add( mp[s2], mp[s1] );
            deg[mp[s1]]++;
            p[mp[s1]][0] = mp[s2];	//x走一步到达x的父亲y，为p数组的初始化
        }
        for( int i = 1; i <= pp; ++i ) {
            if( !deg[i] ) {
                dep[i] = 0;
                dfs( i, i );
                break;
            }
        }
        for( int j = 1; j <= 25; ++j ) {
            for( int i = 1; i <= pp; ++i ) {
                p[i][j] = p[p[i][j-1]][j-1];	//某个点向根走2^n到达j，那么就等价于先走2^(n-1)到达的那个点，再走2^(n-1)。
						//注意循环顺序，和RMQ一样，都是先求出2^(n-1),才能在2^(n-1)的基础上求2^n.
            }
        }
        for( int i = 1; i <= m; ++i ) {
            cin >> s1 >> s2;
            int u = mp[s1], v = mp[s2];
            int c = LCA( u, v );
            int ans = dep[u] - dep[c];
            if( v != c )
                ans++;
            cout << ans << endl;
        }
    }
    return 0;
}