HDU 6203 ping ping ping 最近公共祖先 树状数组

原题链接

题意

• 给我们一棵n+1节点，n条边的树，然后给我们p条路径（每条路径给出两个端点）。我们需要从树上选出一些点，使得每条路径都至少包含我们选出的一个点。求最少选多少点。

思路

• 以1为根，我们可以发现如果两条路径相交，设两条路径两端点的LCA分别是u，v，其中u的深度大于等于v的深度，则交点一定包含u。

• 所以我们按照LCA的深度对读入的路径进行排序，然后按照深度从大到小进行遍历，如果发现当前路径的两端点属于之前已经标记过的子树，则此路径不需要选点，否则选择本条路径两端点的LCA，同时将该点所代表的子树进行标记，可以使用树链剖分和树状数组来完成这一任务。

AC代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define lowbit(x) (x&(-x))

using namespace std;

const int N = 10000;

int n;
int fir[N + 5], nex[N * 2 + 5], vv[N * 2 + 5], co = 0;

void adde(int u, int v)
{
    vv[++co] = v;
    nex[co] = fir[u];
    fir[u] = co;
}

int fa[N + 5];
int sq[N + 5], rk[N + 5], dep[N + 5];
int st[N + 5], sz[N + 5], chi[N + 5];

int cc[N + 5];

void update(int x, int v)
{
    while (x <= n + 1)
    {
        cc[x] += v;
        x += lowbit(x);
    }
}

int qu(int x)
{
    int res = 0;
    while (x)
    {
        res += cc[x];
        x -= lowbit(x);
    }
    return res;
}

struct ab
{
    int f;
    int u;
    int v;
    bool operator < (const ab& c) const
    {
        return dep[f] > dep[c.f];
    }
} qq[N * 5 + 5];

void dfs1(int o, int f)
{
    fa[o] = f;
    dep[o] = dep[f] + 1;
    sz[o] = 1;
    chi[o] = 0;
    for (int i = fir[o]; i; i = nex[i])
    {
        if (vv[i] == f)
        {
            continue;
        }
        dfs1(vv[i], o);
        sz[o] += sz[vv[i]];
        if (sz[vv[i]] > sz[chi[o]])
        {
            chi[o] = vv[i];
        }
    }
}

void dfs2(int o, int f, int top)
{
    sq[++co] = o;
    rk[o] = co;
    st[o] = top;
    if (chi[o])
    {
        dfs2(chi[o], o, top);
    }
    for (int i = fir[o]; i; i = nex[i])
    {
        if (vv[i] == f || vv[i] == chi[o])
        {
            continue;
        }
        dfs2(vv[i], o, vv[i]);
    }
}

int lca(int u, int v)
{
    while (st[u] != st[v])
    {
        if (dep[st[u]] < dep[st[v]])
        {
            swap(u, v);
        }
        u = fa[st[u]];
    }
    return dep[u] < dep[v] ? u : v;
}

int main()
{
    while (scanf("%d", &n) == 1)
    {
        memset(fir, 0, sizeof(int) * (n + 2));
        memset(cc, 0, sizeof(int) * (n + 2));
        co = 0;
        for (int i = 1; i <= n; ++i)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            ++u;
            ++v;
            adde(u, v);
            adde(v, u);
        }
        co = 0;
        dfs1(1, 0);
        dfs2(1, 0, 1);
        int q;
        scanf("%d", &q);
        for (int i = 1; i <= q; ++i)
        {
            int u, v;
            scanf("%d%d", &u, &v);
            ++u;
            ++v;
            qq[i] = {lca(u, v), u, v};
        }
        sort(qq + 1, qq + q + 1);
        int ans = 0;
        for (int i = 1; i <= q; ++i)
        {
            if (qu(rk[qq[i].u]) || qu(rk[qq[i].v]))
            {
                continue;
            }
            ++ans;
            update(rk[qq[i].f], 1);
            update(rk[qq[i].f] + sz[qq[i].f], -1);
        }
        printf("%d\n", ans);
    }
    return 0;
}