[hdu5266]区间LCA

题意：给一棵树，求节点L,L+1,...R的最近公共祖先

思路：先对树dfs一下，从根1出发，经过每条边时记录一下终点和到达这个点的时间截，令r[u]表示到达u这个节点的最早时间截,t[x]表示在时间截x时到达的节点编号，假设对于两个节点u,v，设r[u]<r[v]，则在t[r[u]], t[r[u]+1], ..., t[r[v]]这个序列里面一定包含了u和v的LCA。要找出这个LCA也不难，由于这个序列里面的所有节点只有u和v的LCA这个节点的r值最小，于是可以用RMQ求出这个最小r值，然后再利用t数组就得到了LCA的节点编号。对于多个节点的LCA处理方法类似，只需找到多个节点中的r值的最小和最大值，相当于找到了r[u]和r[v]，剩下的就与两个点的LCA一样了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
#pragma comment(linker, "/STACK:10240000,10240000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>  
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
 
const int maxn = 3e5 + 7;
 
struct Graph {
    vector<vector<int> > G;
    void clear() { G.clear(); }
    void resize(int n) { G.resize(n + 2); }
    vector<int> & operator [] (int x) { return G[x]; }
    int size() { return G.size(); }
    void add(int u, int v) { G[u].push_back(v); }
};
Graph G;
 
struct ST {
    struct FI {
        int a[21];
        int & operator [] (int x) {
            return a[x];
        }
    };
    vector<FI> dp;
    vector<int> T;
 
    void init(int a[], int n, int (*F)(int, int)) {
        dp.clear();
        dp.resize(n);
        for (int i = 0; i < n; i ++) dp[i][0] = a[i];
        for (int j = 1; (1 << j) <= n; j ++) {
            for (int i = 0; i + (1 << j) - 1 < n; i ++) {
                dp[i][j] = F(dp[i][j - 1], dp[i + (1 << (j - 1))][j - 1]);
            }
        }
        T.clear();
        T.resize(n);
        T[1] = 0;
        for (int i = 2; i <= n; i ++) {
            T[i] = T[i - 1];
            if ((i & (i - 1)) == 0) T[i] ++;
        }
    }
    int query(int L, int R, int (*F)(int, int)) {
        int t = T[R - L + 1];
        return F(dp[L][t], dp[R - (1 << t) + 1][t]);
    }
};
int fmin(int a, int b) { return a < b? a : b; }
int fmax(int a, int b) { return a > b? a : b; }
struct LCA {
    int clock, r[maxn], t[2 * maxn], b[2 * maxn];
    bool vis[maxn];
    ST st0, st1, st2;
    void dfs(int rt) {
        r[rt] = clock;
        t[clock ++] = rt;
        vis[rt] = true;
        int sz = G[rt].size();
        for (int i = 0; i < sz; i ++) {
            int u = G[rt][i];
            if (!vis[u]) {
                dfs(u);
                t[clock ++] = rt;
            }
        }
    }
    void work() {
        clock = 0;
        memset(vis, 0, sizeof(vis));
        dfs(1);
        for (int i = 0; i < clock; i ++) b[i] = r[t[i]];
        st0.init(b, clock, fmin);
        st1.init(r + 1, (clock + 1) >> 1, fmax);
        st2.init(r + 1, (clock + 1) >> 1, fmin);
    }
    int lca_all(int L, int R) {
        L --; R --;
        int lp = st2.query(L, R, fmin), rp = st1.query(L, R, fmax);
        return t[st0.query(lp, rp, fmin)];
    }
};
 
LCA lca;
int main() {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int n, m;
    while (cin >> n) {
        G.clear();
        G.resize(n);
        for (int i = 0; i < n - 1; i ++) {
            int u, v;
            scanf("%d%d", &u, &v);
            G.add(u, v);
            G.add(v, u);
        }
        lca.work();
        cin >> m;
        for (int i = 0; i < m; i ++) {
            int L, R;
            scanf("%d%d", &L, &R);
            printf("%d\n", lca.lca_all(L, R));
        }
    }
    return 0;
}

 

posted @ 2015-06-12 19:16  jklongint  阅读(533)  评论(0)  编辑  收藏  举报