[CodeVS2370] 小机房的树 (LCA, 树链剖分, LCT)

Description

　　小机房有棵焕狗种的树，树上有N个节点，节点标号为0到N-1，有两只虫子名叫飘狗和大吉狗，分居在两个不同的节点上。有一天，他们想爬到一个节点上去搞基，但是作为两只虫子，他们不想花费太多精力。

　　已知从某个节点爬到其父亲节点要花费 c 的能量（从父亲节点爬到此节点也相同），他们想找出一条花费精力最短的路，以使得搞基的时候精力旺盛，他们找到你要你设计一个程序来找到这条路，要求你告诉他们最少需要花费多少精力

Input

　　第一行一个n，接下来n-1行每一行有三个整数u，v, c 。表示节点 u 爬到节点 v 需要花费 c 的精力。
　　第n+1行有一个整数m表示有m次询问。接下来m行每一行有两个整数 u ，v 表示两只虫子所在的节点

Output

　　一共有m行，每一行一个整数，表示对于该次询问所得出的最短距离。

Sample Input

3

1 0 1

2 0 1

3

1 0

2 0

1 2

Sample Output

1

1

2

HINT

　　1<=n<=50000， 1<=m<=75000， 0<=c<=1000

Source

Solution

　　倍增求LCA, $O((n + m)logn)$

#include <bits/stdc++.h>
using namespace std;
struct edge
{
    int v, w, nxt;
}e[100005];
int fst[50005], q[50005], front, back;
int fa[17][50005], dis[50005], dep[50005];

void addedge(int i, int u, int v, int w)
{
    e[i] = (edge){v, w, fst[u]}, fst[u] = i;
}

int LCA(int u, int v)
{
    if(dep[u] > dep[v]) swap(u, v);
    for(int i = 16; ~i; i--)
        if(dep[fa[i][v]] >= dep[u])
            v = fa[i][v];
    if(u == v) return u;
    for(int i = 16; ~i; i--)
        if(fa[i][u] != fa[i][v])
            u = fa[i][u], v = fa[i][v];
    return fa[0][u];
}

int main()
{
    int n, m, u, v, w;
    cin >> n;
    for(int i = 1; i < n; i++)
    {
        cin >> u >> v >> w;
        addedge(i << 1, ++u, ++v, w);
        addedge(i << 1 | 1, v, u, w);
    }
    q[++back] = 1, dep[1] = fa[0][1] = 1;
    while(front != back)
    {
        u = q[++front];
        for(int i = fst[u]; i; i = e[i].nxt)
            if(e[i].v != fa[0][u])
            {
                q[++back] = e[i].v;
                dep[e[i].v] = dep[u] + 1;
                fa[0][e[i].v] = u;
                dis[e[i].v] = dis[u] + e[i].w;
            }
    }
    for(int i = 1; i <= 16; i++)
        for(int j = 1; j <= n; j++)
            fa[i][j] = fa[i - 1][fa[i - 1][j]];
    cin >> m;
    while(m--)
    {
        cin >> u >> v, u++, v++;
        cout << dis[u] + dis[v] - 2 * dis[LCA(u, v)] << endl;
    }
    return 0;
}

　　Tarjan求LCA, $O(n + m)$（写法较鬼畜）

#include <bits/stdc++.h>
using namespace std;
struct edge
{
    int v, w, nxt;
}e[100005];
struct query
{
    int u, v, nxt;
}q[150005];
int efst[50005], qfst[75005], fa[50005], lca[75005], dis[50005];
bool vis[50005];

void addedge(int i, int u, int v, int w)
{
    e[i] = (edge){v, w, efst[u]}, efst[u] = i;
}

void addquery(int i, int u, int v)
{
    q[i] = (query){u, v, qfst[u]}, qfst[u] = i;
}

int get_dis(int i)
{
    return dis[q[i << 1].u] + dis[q[i << 1].v] - 2 * dis[lca[i]];
}

int getfa(int x)
{
    return fa[x] = x == fa[x] ? x : getfa(fa[x]);
}

void Tarjan(int u)
{
    fa[u] = u, vis[u] = true;
    for(int i = efst[u]; i; i = e[i].nxt)
        if(!vis[e[i].v])
        {
            dis[e[i].v] = dis[u] + e[i].w;
            Tarjan(e[i].v);
            fa[e[i].v] = u;
        }
    for(int i = qfst[u]; i; i = q[i].nxt)
    {
        int v = q[i].u == u ? q[i].v : q[i].u;
        if(vis[v]) lca[i >> 1] = getfa(fa[v]);
    }
}

int main()
{
    int n, m, u, v, w;
    cin >> n;
    for(int i = 1; i < n; i++)
    {
        cin >> u >> v >> w;
        addedge(i << 1, ++u, ++v, w);
        addedge(i << 1 | 1, v, u, w);
    }
    cin >> m;
    for(int i = 1; i <= m; i++)
    {
        cin >> u >> v;
        addquery(i << 1, ++u, ++v);
        addquery(i << 1 | 1, v, u);
    }
    Tarjan(1);
    for(int i = 1; i <= m; i++)
        cout << get_dis(i) << endl;
    return 0;
}

　　树链剖分求LCA, $O(mlogn)$，我习惯把树剖维护的7个信息写到结构体里。

#include <bits/stdc++.h>
using namespace std;
struct edge
{
    int v, w, nxt;
}e[100005];
struct point
{
    int fa, siz, son, dep, dis, dfn, top;
}p[50005];
int ptot, fst[50005];

void addedge(int i, int u, int v, int w)
{
    e[i] = (edge){v, w, fst[u]}, fst[u] = i;
}

void DFS1(int u)
{
    p[u].siz = 1;
    for(int i = fst[u]; i; i = e[i].nxt)
        if(e[i].v != p[u].fa)
        {
            p[e[i].v].fa = u;
            p[e[i].v].dep = p[u].dep + 1;
            p[e[i].v].dis = p[u].dis + e[i].w;
            DFS1(e[i].v);
            p[u].siz += p[e[i].v].siz;
            if(p[e[i].v].siz > p[p[u].son].siz)
                p[u].son = e[i].v;
        }
}

void DFS2(int u, int top)
{
    p[u].dfn = ++ptot, p[u].top = top;
    if(p[u].son) DFS2(p[u].son, top);
    for(int i = fst[u]; i; i = e[i].nxt)
        if(e[i].v != p[u].fa && e[i].v != p[u].son)
            DFS2(e[i].v, e[i].v);
}

int LCA(int u, int v)
{
    while(p[u].top != p[v].top)
    {
        if(p[p[u].top].dep > p[p[v].top].dep) swap(u, v);
        v = p[p[v].top].fa;
    }
    if(p[u].dep > p[v].dep) swap(u, v);
    return u;
}


int main()
{
    int n, m, u, v, w;
    cin >> n;
    for(int i = 1; i < n; i++)
    {
        cin >> u >> v >> w;
        addedge(i << 1, ++u, ++v, w);
        addedge(i << 1 | 1, v, u, w);
    }
    p[1].dep = 1, DFS1(1), DFS2(1, 1);
    cin >> m;
    while(m--)
    {
        cin >> u >> v, u++, v++;
        cout << p[u].dis + p[v].dis - 2 * p[LCA(u, v)].dis << endl;
    }
    return 0;
}

 　　LCT, $O(mlog^{2}n)$

#include <bits/stdc++.h>
using namespace std;
struct LCT
{
    int fa, c[2], rev, key, sum;
    int& operator [] (int i)
    {
        return c[i];
    }
}a[100005];
int sta[100005], top;

void push_up(int k)
{
    a[k].sum = a[a[k][0]].sum + a[a[k][1]].sum + a[k].key;
}

void push_down(int k)
{
    if(a[k].rev)
    {
        a[a[k][0]].rev ^= 1, a[a[k][1]].rev ^= 1;
        swap(a[k][0], a[k][1]), a[k].rev = 0;
    }
}

bool isroot(int x)
{
    return a[a[x].fa][0] != x && a[a[x].fa][1] != x;
}

void rotate(int x)
{
    int y = a[x].fa, z = a[y].fa;
    int dy = a[y][1] == x, dz = a[z][1] == y;
    if(!isroot(y)) a[z][dz] = x;
    a[y][dy] = a[x][dy ^ 1], a[a[x][dy ^ 1]].fa = y;
    a[x][dy ^ 1] = y, a[y].fa = x, a[x].fa = z;
    push_up(y);
}

void splay(int x)
{
    sta[top = 1] = x;
    for(int i = x; !isroot(i); i = a[i].fa)
        sta[++top] = a[i].fa;
    while(top)
        push_down(sta[top--]);
    while(!isroot(x))
    {
        int y = a[x].fa, z = a[y].fa;
        if(!isroot(y))
            if(a[y][1] == x ^ a[z][1] == y) rotate(x);
            else rotate(y);
        rotate(x);
    }
    push_up(x);
}

void access(int x)
{
    for(int i = 0; x; x = a[x].fa)
        splay(x), a[x][1] = i, i = x;
}

void make_root(int x)
{
    access(x), splay(x), a[x].rev ^= 1;
}

void link(int x, int y)
{
    make_root(x), a[x].fa = y;
}

void cut(int x, int y)
{
    make_root(x), access(y), splay(y), a[y][0] = a[x].fa = 0;
}

int find_root(int x)
{
    access(x), splay(x);
    while(a[x][0])
        x = a[x][0];
    return x;
}

int main()
{
    int n, m, u, v, w;
    cin >> n;
    for(int i = 1; i < n; i++)
    {
        cin >> u >> v >> w;
        a[i + n].sum = a[i + n].key = w;
        link(++u, i + n), link(i + n, ++v);
    }
    cin >> m;
    while(m--)
    {
        cin >> u >> v;
        make_root(++u), access(++v), splay(v);
        printf("%d
", a[v].sum);
    }
    return 0;
}