POJ1986_Distance Queries_LCA||树链剖分

题意

给定一棵树，q 个询问。每个询问包含两个节点，要求输出两个节点的距离。

思路

解法一：二分法求LCA，然后 dis(u, v) = dis(root, u) + dis(root, v) - 2 * dis(root, lca(u, v))
解法二：树链剖分

链接

http://poj.org/problem?id=1986

代码

LCA版本

#include<cstdio>
#include<iostream>
#include<cstring>
#include<vector>

using namespace std;

const int maxn = 4e4 + 10;
const int maxlogn = 16;

struct edge{
    int to, dis;
    edge(){}
    edge(int to, int dis): to(to), dis(dis){}
};

int n, m, q;
vector<edge> G[maxn];
int root;
int parent[maxlogn][maxn];
int depth[maxn];
int val[maxn], dis[maxn];

void dfs(int v, int p, int d){
    parent[0][v] = p;
    depth[v] = d;
    for(int i = 0; i < G[v].size(); i++){
        if(G[v][i].to != p){
            dis[G[v][i].to] = dis[v] + G[v][i].dis;
            dfs(G[v][i].to, v, d + 1);
        }
    }
}

void init(int V){
    dfs(root, -1, 0);
    for(int k = 0; k + 1 < maxlogn; k++){
        for(int v = 0; v < V; v++){
            if(parent[k][v] < 0) parent[k+1][v] = -1;
            else parent[k+1][v] = parent[k][parent[k][v]];
        }
    }
}

int lca(int u, int v){
    if(depth[u] > depth[v]) swap(u, v);
    for(int k = 0; k < maxlogn; k++){
        if((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
    }

    if(u == v) return u;

    for(int k = maxlogn - 1; k >= 0; k--){
        if(parent[k][u] != parent[k][v]){
            u = parent[k][u];
            v = parent[k][v];
        }
    }

    return parent[0][u];
}

int main(){
//  freopen("in.txt", "r", stdin);

    scanf("%d %d", &n, &m);
    for(int i = 0; i < m; ++i){
        int x, y, l, c;
        scanf("%d %d %d %c", &x, &y, &l, &c);
        x--, y--;
        G[x].push_back(edge(y, l));
        G[y].push_back(edge(x, l));
        val[y] = l;
    }

    for(int i = 0; i < n; ++i){
        if(val[i] == 0){
            root = i;
            break;
        }
    }

    init(n);

    scanf("%d", &q);
    while(q--){
        int x, y;
        scanf("%d %d", &x, &y);
        x--, y--;
        printf("%d\n", dis[x] + dis[y] - 2 * dis[lca(x, y)]);
    }

    return 0;
}

树链剖分版本

#include<cstdio>
#include<iostream>
#include<cstring>

using namespace std;

const int maxn = 4e4 + 10;

struct E{
    int u, v, c;
    E(){}
    E(int a, int b, int d) : u(a), v(b), c(d) {}
};

int n, m, q;
//  深度      子树大小    父亲  dfs序        重儿子 重链顶端    计数器
int dep[maxn], siz[maxn], fa[maxn], id[maxn], son[maxn], top[maxn], tot;
int tre[maxn << 2];
int val[maxn];
//链式前向星
E edge[maxn];
int head[maxn], to[maxn << 1], nxt[maxn << 1], tt = 0;
bool not_root[maxn];

//树链剖分，第一遍dfs
//当前节点，父亲节点
void dfs0(int now, int fat){
    dep[now] = dep[fat] + 1, siz[now] = 1, fa[now] = fat, son[now] = 0;

    for(int i = head[now]; i != -1; i = nxt[i]){
        int v = to[i];
        if(v == fat) continue;

        dfs0(v, now);
        siz[now] += siz[v];                         //更新子树大小
        if(siz[son[now]] < siz[v]) son[now] = v;    //更新重儿子
    }
}

//树链剖分，第二遍dfs
//当前节点，重链顶端
void dfs1(int now, int tp){
    id[now] = ++tot, top[now] = tp;

    //先搜重儿子
    if(son[now]) dfs1(son[now], tp);

    for(int i = head[now]; i != -1; i = nxt[i]){
        int v = to[i];
        if(v == fa[now] || v == son[now]) continue;
        dfs1(v, v);
    }
}

void build(int p, int l, int r){
    if(l == r){
        tre[p] = val[l];
        return;
    }

    int mid = (l + r) >> 1;
    build(p<<1, l, mid);
    build(p<<1|1, mid+1, r);

    tre[p] = tre[p<<1] + tre[p<<1|1];
}

void update(int p, int l, int r, int x, int y){
    if(l == r){
        tre[p] = y;
        return;
    }

    int mid = (l + r) >> 1;
    if(x <= mid) update(p<<1, l, mid, x, y);
    else update(p<<1|1, mid+1, r, x, y);

    tre[p] = tre[p<<1] + tre[p<<1|1];
}

int query(int p, int l, int r, int x, int y){
    if(x <= l && r <= y) return tre[p];

    int mid = (l + r) >> 1;

    int res = 0;
    if(x <= mid) res += query(p<<1, l, mid, x, y);
    if(y > mid) res += query(p<<1|1, mid+1, r, x, y);

    return res;
}

int get_dis(int u, int v){
    int res = 0;

    while(top[u] != top[v]){                            //不在同一条重链上
        if(dep[top[u]] < dep[top[v]]) swap(u, v);

        res += query(1, 1, n, id[top[u]], id[u]);       //深度大的往上爬
        u = fa[top[u]];
    }

    if(u == v) return res;

    if(dep[u] < dep[v]) swap(u, v);
    res += query(1, 1, n, id[son[v]], id[u]);

    return res;
}

void ins(int f, int t){
    to[tt] = t;
    nxt[tt] = head[f];
    head[f] = tt;
    tt ++;
}

int main(){
//  freopen("in.txt", "r", stdin);

    //链式前向星建图
    memset(head, -1, sizeof head);
    scanf("%d %d", &n, &m);

    for(int i = 1; i <= m; i++){
        int x, y, l;
        char c;
        scanf("%d %d %d %c", &x, &y, &l, &c);
        not_root[y] = true;
        edge[i].u = x, edge[i].v = y, edge[i].c = l;
        ins(x, y);ins(y, x);
    }

    for(int i = 1; i <= n; ++i){
        if(!not_root[i]){
            dfs0(i, 0);
            dfs1(i, i);
            break;
        }
    }

    for(int i = 1; i <= n-1; i++){
        if(dep[edge[i].u] < dep[edge[i].v]) swap(edge[i].u, edge[i].v);
        val[id[edge[i].u]] = edge[i].c;
    }

    //构造线段树，维护区间和
    build(1, 1, n);

    scanf("%d", &q);
    while(q--){
        int x, y;
        scanf("%d %d", &x, &y);
        printf("%d\n", get_dis(x, y));
    }

    return 0;
}