图论与位运算：多源最短路径的优化策略

1. 题目背景与问题描述

今天我们来探讨一道来自AtCoder Beginner Contest 245的G题——"Foreign Friends"。这是一道结合了图论和位运算的典型算法题，考察了多源最短路径算法在特定条件下的优化应用。

题目描述如下：给定一个无向图，每个节点有一个颜色属性。我们需要为每个节点找到距离最近的"外国朋友"——即颜色不同的特殊节点。特殊节点由题目给出，数量为L个。

1.1 输入输出规范

输入包含：

• 节点数N，边数M
• 特殊节点数量K（实际特殊节点数量为L，题目描述可能有笔误）
• 每个节点的颜色A[i]（1≤i≤N）
• L个特殊节点的编号B[j]（1≤j≤L）
• M条边的信息（u, v, c）表示节点u和v之间有一条权值为c的边

输出要求：

• 对于每个节点i，输出其到最近的不同颜色特殊节点的距离
• 如果不存在这样的节点，输出-1

2. 基础思路分析

2.1 无颜色限制的情况

如果没有颜色限制，这个问题就是典型的多源最短路径问题。我们可以采用堆优化的Dijkstra算法：

1. 将所有特殊节点加入优先队列，初始距离设为0
2. 执行标准的Dijkstra算法，记录每个节点到最近特殊节点的距离

这种方法的时间复杂度为O(M log N)，对于大规模图也是可行的。

2.2 引入颜色限制后的挑战

当加入颜色限制后（即要求目标特殊节点颜色与当前节点不同），直接套用上述方法就不适用了。最直观的暴力解法是：

对于每个节点i：

1. 筛选出所有颜色≠A[i]的特殊节点
2. 以这些节点为源点，运行多源Dijkstra
3. 记录最小距离

这种方法的复杂度高达O(L × M log N)，当L很大时（比如L≈N），复杂度将达到O(NM log N)，这在N和M都是1e5量级时显然无法接受。

3. 关键优化思路

3.1 位运算性质的应用

观察到颜色是用整数表示的，我们可以利用位运算的性质进行优化。关键观察点是：

任何两个不同的整数，在它们的二进制表示中至少有一位不同。

这意味着对于任意两个颜色不同的节点，至少存在一个二进制位，使得这两个节点在该位上的值不同。

3.2 按位分治策略

基于上述观察，我们可以设计如下算法：

1. 枚举每一个二进制位b（从0到17，因为颜色值≤1e5）
2. 对于每个二进制位b，考虑两种情况：
   • 情况0：特殊节点在该位为0
   • 情况1：特殊节点在该位为1
3. 对每种情况：
   • 以所有满足该位条件的特殊节点为源点，运行多源Dijkstra
   • 对于所有不满足该位条件的节点，用求得的最短距离更新答案

这样，对于每个节点i，其颜色A[i]与某个特殊节点颜色不同，必然存在至少一个二进制位b，使得A[i]和该特殊节点在b位上的值不同。因此，正确性得以保证。

3.3 复杂度分析

• 外层循环：枚举二进制位，最多循环logV次（V是颜色最大值）
• 内层操作：运行两次多源Dijkstra（对应位为0和1的情况）
• 每次Dijkstra的复杂度：O(M log N)

总复杂度：O(logV × M log N)，其中V是颜色值的上限。对于V=1e5，logV≈17，这在N和M为1e5量级时是可接受的。

4. 代码实现详解

4.1 数据结构准备

cpp复制#include <bits/stdc++.h>
using namespace std;
using i64 = long long;

constexpr i64 inf = 1E18;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int N, M, K, L;
    cin >> N >> M >> K >> L;
    vector<int> A(N), B(L);
    for (int i = 0; i < N; ++i) cin >> A[i];
    for (int i = 0; i < L; ++i) {
        cin >> B[i];
        --B[i]; // 转换为0-based
    }
    
    vector<vector<array<int, 2>>> adj(N);
    for (int i = 0; i < M; ++i) {
        int u, v, c;
        cin >> u >> v >> c;
        --u; --v; // 转换为0-based
        adj[u].push_back({v, c});
        adj[v].push_back({u, c});
    }

这部分代码处理输入并构建图的邻接表表示。注意节点编号从1-based转换为0-based的细节处理。

4.2 核心算法实现

cpp复制    vector<i64> ans(N, inf);
    for (int b = 0; b < 18; ++b) {
        for (int o = 0; o < 2; ++o) {
            priority_queue<pair<i64, int>, vector<pair<i64, int>>, greater<>> q;
            vector<i64> dis(N, inf);
            
            // 初始化源点
            for (int i = 0; i < L; ++i) {
                if ((A[B[i]] >> b & 1) == o) {
                    q.emplace(0, B[i]);
                    dis[B[i]] = 0;
                }
            }
            
            // Dijkstra主循环
            while (!q.empty()) {
                auto [d, u] = q.top();
                q.pop();
                if (dis[u] < d) continue;
                
                for (auto &[v, w] : adj[u]) {
                    if (d + w < dis[v]) {
                        dis[v] = d + w;
                        q.emplace(dis[v], v);
                    }
                }
            }
            
            // 更新答案
            for (int i = 0; i < N; ++i) {
                if ((A[i] >> b & 1) != o) {
                    ans[i] = min(ans[i], dis[i]);
                }
            }
        }
    }

这部分是算法的核心：

1. 外层循环枚举二进制位b（0到17）
2. 内层循环枚举该位的值o（0或1）
3. 对每种(b,o)组合：
   • 初始化优先队列，将所有在该位满足条件的特殊节点加入
   • 执行Dijkstra算法
   • 对于所有在该位不满足条件的节点，用求得的最短距离更新答案

4.3 结果输出

cpp复制    for (int i = 0; i < N; ++i) {
        if (ans[i] == inf) ans[i] = -1;
        cout << ans[i] << " \n"[i + 1 == N];
    }
    
    return 0;
}

最后处理输出，将未更新的inf值转为-1，并按格式输出结果。

5. 算法优化与注意事项

5.1 位数的选择

代码中固定枚举了18位（0到17），这是因为题目中颜色值的上限是1e5，而2^16=65536，2^17=131072，所以17位足够覆盖所有可能的颜色值。

5.2 优先队列的使用

使用std::priority_queue配合std::greater实现了最小堆，确保每次取出当前距离最小的节点。这是Dijkstra算法的标准实现方式。

5.3 距离更新的剪枝

cpp复制if (dis[u] < d) continue;

这一行是Dijkstra算法的经典优化，避免处理已经找到更优解的节点。

5.4 实际应用中的考量

1. 内存使用：算法需要存储多个距离数组，但通过合理复用，空间复杂度保持在O(N)。
2. 并行化潜力：不同二进制位的处理是独立的，理论上可以并行计算以提高速度。
3. 极端情况：当所有特殊节点颜色相同时，算法仍然有效，但所有与该颜色相同的节点的结果将为-1。

6. 常见问题与调试技巧

6.1 为什么我的程序超时？

可能原因：

1. 没有使用优先队列优化，使用了普通的队列（退化为BFS，无法处理带权图）
2. 在Dijkstra中没有正确剪枝，重复处理节点
3. 图的表示使用了低效的数据结构（如邻接矩阵而非邻接表）

解决方案：

1. 确保使用std::priority_queue
2. 检查剪枝逻辑是否正确
3. 使用vector<vector<pair<int, int>>>等高效邻接表表示

6.2 为什么结果不正确？

可能原因：

1. 节点编号处理错误（1-based vs 0-based）
2. 位运算逻辑错误（如位掩码使用不当）
3. 距离更新条件错误（应为d + w < dis[v]）

调试建议：

1. 对小规模测试用例手动计算验证
2. 输出中间结果检查位运算是否正确
3. 使用断言检查关键不变量

6.3 如何进一步优化？

1. 位运算优化：如果知道颜色值的具体范围，可以减少枚举的位数
2. 数据结构优化：使用更高效的优先队列实现（如Fibonacci堆）
3. 预处理：如果查询次数很多，可以考虑预处理所有可能的颜色组合

7. 算法扩展与应用

这种基于位运算的分治策略可以应用于其他有"差异"约束的问题，例如：

1. 寻找满足某种异或条件的路径
2. 处理带有多维属性的最近邻搜索
3. 解决带约束的聚类问题

关键思路是将复杂的差异条件分解为多个独立的二进制位条件，从而降低问题复杂度。

在实际工程中，类似的技巧也常用于：

1. 数据库查询优化（位图索引）
2. 机器学习中的特征选择
3. 网络路由算法

理解这种按位处理的思维方式，对于解决复杂的算法问题非常有帮助。