最近公共祖先 LCA on 安洛的小窝

[蓝桥杯2024省A]零食采购题解

Thu, 23 Jan 2025 16:11:58 +0800

封面图源 https://www.pixiv.net/artworks/87550307

题目描述

小蓝准备去星际旅行，出发前想在本星系采购一些零食，星系内有 $n$ 颗星球，由 $n-1$ 条航路连接为连通图，第 $i$ 颗星球卖第 $c_i$ 种零食特产。小蓝想出了 $q$ 个采购方案，第 $i$ 个方案的起点为星球 $s_i$ ，终点为星球 $t_i$ ，对于每种采购方案，小蓝将从起点走最短的航路到终点，并且可以购买所有经过的星球上的零食（包括起点终点），请计算每种采购方案最多能买多少种不同的零食。

输入格式

输入的第一行包含两个正整数 $n$，$q$，用一个空格分隔。
第二行包含 $n$ 个整数 $c_1,c_2,\cdots, c_n$，相邻整数之间使用一个空格分隔。
接下来 $n - 1$ 行，第 $i$ 行包含两个整数 $u_i,v_i$，用一个空格分隔，表示一条航路将星球 $u_i$ 与 $v_i$ 相连。
接下来 $q$ 行，第 $i$ 行包含两个整数 $s_i , t_i $，用一个空格分隔，表示一个采购方案。

输出格式

输出 $q$ 行，每行包含一个整数，依次表示每个采购方案的答案。

样例 #1

样例输入 #1

样例输出 #1

1
2

3
2

提示

第一个方案路线为 ${4, 2, 1, 3}$，可以买到第 $1, 2, 3$ 种零食；
第二个方案路线为 ${1, 2, 4}$，可以买到第 $1, 2$ 种零食。

对于 20% 的评测用例，$1 ≤ n, q ≤ 5000 $；
对于所有评测用例，$1 ≤ n, q ≤ 10^5，1 ≤ c_i ≤ 20，1 ≤ u_i , v_i ≤ n，1 ≤ s_i , t_i ≤ n$。

解题思路

很简单的 LCA。用倍增 LCA 就可以了，时间复杂度 $O(qlogn)$。有点麻烦的是这个 $ci$ 的处理。朴素 LCA 很好处理这个 $ci$，反正是一个点一个点地回溯的，回溯的时候顺便统计 $ci$ 就好。倍增 LCA 也可以处理路径上的信息，但需要在建树的时候预处理这些信息。在祖先节点数组上记录从该节点到祖先节点（最好是半闭半开区间方便后续统计）所能够买到的所有零食种类，每次扩展祖先节点数组的时候将两个中间祖先的值合并到新祖先上即可。因为每个祖先本质上都是通过父亲扩展而来，因此并不会有遗漏（如果这点有疑问的自己模拟一遍这个过程就明白了）。这要求有一个能够方便地存储所有零食种类和执行合并操作的数据结构。我一开始使用了 unordered_set，用起来非常恶心。看了题解之后发现因为 $c_i$ 的范围较小，可以用 bitset，用了 bitset 马上就 AC 了。

代码

附上通过代码。这道题洛谷的数据终于不犯病了，洛谷和蓝桥杯官网都能过。

#include <array>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
#include <vector>
using namespace std;

const int MAXN = 1e5;
const int MAXCI = 20;
using bs = bitset<MAXCI + 5>;
int n, q;
struct node
{
    int c;
    list<int> v;
};
struct tnode
{
    struct father
    {
        int v;
        bs c;
    };
    vector<father> f;
    list<int> s;
    int d;
};
array<node, MAXN + 5> g;
array<tnode, MAXN + 5> tree;

void dfs(int p, int f, int d)
{
    tree.at(p).d = d;
    if (f != 0)
    {
        tree.at(p).f.push_back({f, bs(1 << g.at(p).c)});
    }
    for (auto &i : g.at(p).v)
    {
        if (i != f)
        {
            tree.at(p).s.push_back(i);
        }
    }
    for (auto i = 0; i < tree.at(p).f.size(); i++)
    {
        auto &f1 = tree.at(p).f;
        auto &f2 = tree.at(f1.at(i).v).f;
        if (f2.size() > i)
        {
            f1.push_back(f2.at(i));
            f1.rbegin()->c |= f1.at(i).c;
        }
    }
    for (auto &i : tree.at(p).s)
    {
        dfs(i, p, d + 1);
    }
}
int lca(int s, int t)
{
    bs ans(0);
    while (tree.at(s).d > tree.at(t).d)
    {
        auto logd = static_cast<int>(log2(tree.at(s).d - tree.at(t).d));
        auto &f = tree.at(s).f.at(logd);
        ans |= f.c;
        s = f.v;
    }
    while (tree.at(t).d > tree.at(s).d)
    {
        auto logd = static_cast<int>(log2(tree.at(t).d - tree.at(s).d));
        auto &f = tree.at(t).f.at(logd);
        ans |= f.c;
        t = f.v;
    }
    assert(tree.at(s).d == tree.at(t).d);
    while (s != t)
    {
        auto &f1 = tree.at(s).f;
        auto &f2 = tree.at(t).f;
        auto logd = static_cast<int>(log2(tree.at(s).d));
        for (auto i = logd; i >= 0; i--)
        {
            if (f1.at(i).v == f2.at(i).v)
                continue;
            ans |= f1.at(i).c;
            s = f1.at(i).v;
            ans |= f2.at(i).c;
            t = f2.at(i).v;
        }
        if (f1.begin()->v == f2.begin()->v)
        {
            auto i = 0;
            ans |= f1.at(i).c;
            s = f1.at(i).v;
            ans |= f2.at(i).c;
            t = f2.at(i).v;
            break;
        }
    }
    ans |= (1 << g.at(s).c);
    return ans.count();
}
int main()
{
    cin >> n >> q;
    for (auto i = 1; i <= n; i++)
    {
        int c;
        cin >> c;
        g.at(i).c = c;
    }
    for (auto i = 1; i <= n - 1; i++)
    {
        int u, v;
        cin >> u >> v;
        g.at(u).v.push_back(v);
        g.at(v).v.push_back(u);
    }
    dfs(1, 0, 0);
    for (auto i = 1; i <= q; i++)
    {
        int s, t;
        cin >> s >> t;
        cout << lca(s, t) << endl;
    }
    return 0;
}

[蓝桥杯2023省A]网络稳定性题解

Sat, 18 Jan 2025 11:01:57 +0800

封面图：https://www.pixiv.net/artworks/126215041

题目描述

洛谷P9235

有一个局域网，由 $n$ 个设备和 $m$ 条物理连接组成，第 $i$ 条连接的稳定性为 $w_i$。

对于从设备 $A$ 到设备 $B$ 的一条经过了若干个物理连接的路径，我们记这条路径的稳定性为其经过所有连接中稳定性最低的那个。

我们记设备 $A$ 到设备 $B$ 之间通信的稳定性为 $A$ 至 $B$ 的所有可行路径的稳定性中最高的那一条。

给定局域网中的设备的物理连接情况，求出若干组设备 $x_i$ 和 $y_i$ 之间的通信稳定性。如果两台设备之间不存在任何路径，请输出 $-1$。

输入格式

输入的第一行包含三个整数 $n,m,q$，分别表示设备数、物理连接数和询问数。

接下来 $m$ 行，每行包含三个整数 $u_i,v_i,w_i$，分别表示 $u_i$ 和 $v_i$ 之间有一条稳定性为 $w_i$ 的物理连接。

接下来 $q$ 行，每行包含两个整数 $x_i,y_i$，表示查询 $x_i$ 和 $y_i$ 之间的通信稳定性。

输出格式

输出 $q$ 行，每行包含一个整数依次表示每个询问的答案。

样例 #1

样例输入 #1

样例输出 #1

1
2
3

-1
3
5

提示

【评测用例规模与约定】

对于 $30 %$ 的评测用例，$n,q \leq 500$，$m \leq 1000$；

对于 $60 %$ 的评测用例，$n,q \leq 5000$，$m \leq 10000$；

对于所有评测用例，$2 \leq n,q \leq 10^5$，$1 \leq m \leq 3 \times 10^5$，$1 \leq u_i,v_i,x_i,y_i \leq n$，$ 1 \leq w_i \leq 10^6$，$u_i \neq v_i$，$x_i \neq y_i$。

解题思路

这道题最开始很容易往最短路的方向想，但是最短路的复杂度是 $O(n^3)$，对于 $n \leq 10^5$ 的数据量是不可接受的。

注意到路径的稳定性与路径中经过的单条边的边权有关，但与整条路径的长度无关。因此其实可以对每条边做贪心，而不需要像最短路一样计算整条路径的长度。又因为两个设备之间的稳定性为所有可行路径中稳定性最高的一条，因此贪心的策略就是要不断取稳定性高的边，直到设备之间连通起来。这实际上是“最大生成树”。其算法可以采用和最小生成树一样的算法。这样处理之后，我们就可以剪去很多无用的路径，从图中生成几颗“最大生成树”（注意到这不一定是连通图，因此可能得到多颗生成树）。在同一颗生成树内的就是互相连通的，否则不能到达。这可以通过求生成树过程中的并查集来判断。

生成了树之后，就要考虑如何高效地处理查询。尽管经过剪枝，图的路径数已经大大降低了，但每个查询跑一遍搜索大概还是不能接受的。考虑到这是一棵树，可以使用最近公共祖先算法，让两个叶子节点同时向根部回溯直到相遇，记录下回溯过程中经过的最小边权即为答案。

具体实现上，最小生成树算法并不能实际给到一个树的数据结构，只能得到一张有向无环图。可以在算法过程中处理来得到树，我这里直接选择在有向无环图上跑一遍dfs来生成树，时间复杂度 $O(n)$ 。朴素 LCA 的时间复杂度是 $O(n)$ ，每次查询都跑一遍的话最后一个点会超时，需要使用倍增 LCA，倍增 LCA 需要注意倍增的上界，避免数组越界问题。

代码

最后附上代码：

#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <list>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
const int MAXN = 100000, MAXQ = 100000, MAXM = 300000, MAXW = 1000000;
struct edge
{
    int u, v, w;
    bool operator<(const edge &other) const
    {
        return w < other.w;
    }
    bool operator>(const edge &other) const
    {
        return w > other.w;
    }
    bool operator==(const edge &other) const
    {
        return w == other.w;
    }
};
struct ledge
{
    int to, w;
};
struct lnode
{
    list<ledge> e;
};
struct tnode
{
    vector<ledge> fa;
    list<ledge> son;
    int d = -1;
} tree[MAXN + 5];
class ufset
{
    struct ufnode
    {
        int f = -1, d = 1;
    };
    vector<ufnode> node;

  public:
    ufset(int n)
    {
        node.resize(n);
    }
    int find(int a)
    {
        if (node[a].f == -1)
            return a;
        else
            return node[a].f = find(node[a].f);
    }
    int uni(int a, int b)
    {
        a = find(a);
        b = find(b);
        if (a == b)
            return -1;
        if (node[a].d < node[b].d)
            node[a].f = b;
        else
        {
            if (node[a].d == node[b].d)
            {
                node[a].f = b;
                node[b].d++;
            }
            else
            {
                node[b].f = a;
            }
        }
        return 0;
    }
} uf(MAXN + 5);
int n, m, q;

void dfs(int cur, int fa, int d, const vector<lnode> &ln)
{
    tree[cur].d = d;
    for (auto i:ln[cur].e)
    {
        if (fa != -1 && i.to == fa)
        {
            tree[cur].fa.push_back(i);
        }
        else
        {
            tree[cur].son.push_back(i);
        }
    }
    for (int i = 0; i < tree[cur].fa.size(); i++)
    {
        int fa = tree[cur].fa[i].to;
        if (tree[fa].fa.size() <= i)
            break;
        tree[cur].fa.push_back({tree[fa].fa[i].to, min(tree[fa].fa[i].w, tree[cur].fa[i].w)});
    }
    for (auto i : tree[cur].son)
    {
        dfs(i.to, cur, d + 1, ln);
    }
}
void gen_tree()
{
    priority_queue<edge> e;
    for (int i = 0; i < m; i++)
    {
        edge ei;
        cin >> ei.u >> ei.v >> ei.w;
        e.push(std::move(ei));
    }
    int sum = 0;
    vector<lnode> ln(n + 5);
    while (sum < n - 1 && !e.empty())
    {
        edge ei = e.top();
        e.pop();
        if (uf.uni(ei.u, ei.v) == -1)
            continue;
        sum++;
        ln[ei.u].e.push_back({ei.v, ei.w});
        ln[ei.v].e.push_back({ei.u, ei.w});
    }
    for (int i = 1; i <= n; i++)
    {
        if (tree[i].d == -1)
        {
            dfs(i, -1, 0, ln);
        }
    }
}
int lca(int u, int v)
{
    int ans = MAXW + 5;
    while (tree[u].d > tree[v].d)
    {
        int d = log2(tree[u].d - tree[v].d);
        ans = min(tree[u].fa[d].w, ans);
        u = tree[u].fa[d].to;
    }
    while (tree[v].d > tree[u].d)
    {
        int d = log2(tree[v].d - tree[u].d);
        ans = min(tree[v].fa[d].w, ans);
        v = tree[v].fa[d].to;
    }
    assert(tree[u].d == tree[v].d);
    if (u == v)
        return ans;
    while (tree[u].fa[0].to != tree[v].fa[0].to)
    {
        int logd = log2(tree[u].d);
        for (int i = logd; i >= 0; i--)
        {
            if (tree[u].fa[i].to == tree[v].fa[i].to)
                continue;
            ans = min(min(ans, tree[u].fa[i].w), tree[v].fa[i].w);
            u = tree[u].fa[i].to;
            v = tree[v].fa[i].to;
            break;
        }
    }
    ans = min(min(ans, tree[u].fa[0].w), tree[v].fa[0].w);
    return ans;
}
void ans()
{
    for (int i = 0; i < q; i++)
    {
        int u, v;
        cin >> u >> v;
        if (uf.find(u) != uf.find(v))
        {
            cout << -1 << endl;
            continue;
        }
        cout << lca(u, v) << endl;
    }
}

int main()
{
    cin >> n >> m >> q;
    gen_tree();
    ans();
    return 0;
}