UVa 13153 Number of Connected Components

原创于 2025-11-25 16:47:17 发布 · 682 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #青少年编程

数论同时被 2 个专栏收录

68 篇文章

订阅专栏

数据结构

47 篇文章

订阅专栏

题目描述

给定 $N$ 个节点，每个节点标有一个介于 $1$ 到 $10^6$ 之间的整数（包含且标签不一定唯一）。当且仅当两个节点标签的 $GCD\texttt{GCD}$ （最大公约数）大于 $1$ 时，这两个节点之间存在一条边。计算图中连通分量的数量。

输入格式

第一行输入 $T$ （ $\leq 100$ ）表示测试用例的数量。随后是 $T$ 个测试用例。每个测试用例包含两行：第一行是一个数字 $N$ （ $\leq N \leq 10^5$ ）表示节点数量；第二行包含 $N$ 个数字，其中第 $i$ 个（ $\leq i \leq N$ ）数字 $X_i$ （ $\leq X_i \leq 10^6$ ）表示节点 $i$ 的标签。

输出格式

对于每个测试用例，输出一行，包含用例编号和一个整数，表示连通分量的数量。

样例输入

样例输出

Case 1: 2
Case 2: 2

题目分析

这是一个图论问题，需要计算无向图中的连通分量数量。图的构建规则是：如果两个节点标签的 $GCD>1\text{GCD} > 1$ ，则它们之间有一条边。

关键观察

直接建图不可行：节点数量最多可达 $10^5$ ，如果直接两两比较计算 $GCD\text{GCD}$ 并建图，时间复杂度为 $O(N^2)$ ，会超时。
质因数分解是关键：如果两个数有公共质因子，那么它们的 $GCD>1\text{GCD} > 1$ 。因此，我们可以通过质因数分解来间接判断连通性。
特殊处理标签 $1$ ：标签为 $1$ 的节点与其他任何节点的 $GCD\text{GCD}$ 都是 $1$ ，因此每个标签为 $1$ 的节点都是一个孤立的连通分量。

解题思路

核心思想：并查集 + 质因数分解

预处理质数表：使用埃拉托斯特尼筛法预处理出 $1$ 到 $10^6$ 范围内的所有质数。
使用并查集维护连通性：
- 初始化并查集，每个数都是独立的集合
- 对于每个节点标签 $x$ （ $\neq 1$ ），分解其质因数
- 将节点 $x$ 与其所有质因子合并到同一个集合中
- 这样，如果两个节点共享至少一个质因子，它们就会在同一个集合中
统计连通分量：
- 统计标签为 $1$ 的节点数量
- 统计非 $1$ 节点在并查集中的不同根的数量
- 总连通分量数 = 非 $1$ 节点的连通分量数 + $1$ 的节点数量

算法正确性证明

假设节点 $A$ 和节点 $B$ 的标签分别为 $a$ 和 $b$ ，且 $GCD(a,b)>1\text{GCD}(a, b) > 1$ ，那么 $a$ 和 $b$ 至少有一个公共质因子 $p$ 。在算法中：

$A$ 会与质因子 $p$ 合并
$B$ 也会与质因子 $p$ 合并
因此 $A$ 和 $B$ 通过 $p$ 连接在同一个集合中

反之，如果 $A$ 和 $B$ 在同一个集合中，说明它们通过一系列质因子连接，这意味着它们有公共质因子，因此 $GCD(a,b)>1\text{GCD}(a, b) > 1$ 。

时间复杂度分析

筛法预处理： $\log \log M)$ ，其中 $M = 10^6$
质因数分解：每个数最多有 $O(log⁡M)O(\log M)$ 个质因子
并查集操作：近似 $O(α(N))O(\alpha(N))$ ，其中 $α\alpha$ 是反阿克曼函数
总体复杂度： $\log M)$ ，能够处理最大数据范围

代码实现

// Number of Connected Components
// UVa ID: 13153
// Verdict: Accepted
// Submission Date: 2025-11-25
// UVa Run Time: 0.170s
//
// 版权所有（C）2025，邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

const int MAX_A = 1000000;
vector<int> primes;
bool isPrime[MAX_A + 1];
int parent[MAX_A + 1];

int findRoot(int x) {
    return parent[x] == x ? x : parent[x] = findRoot(parent[x]);
}

void unionSets(int a, int b) {
    int ra = findRoot(a), rb = findRoot(b);
    if (ra != rb) parent[ra] = rb;
}

void sieve() {
    memset(isPrime, true, sizeof(isPrime));
    for (int i = 2; i <= MAX_A; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i + i; j <= MAX_A; j += i)
                isPrime[j] = false;
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    sieve();
    int T;
    cin >> T;
    for (int caseNum = 1; caseNum <= T; caseNum++) {
        int n;
        cin >> n;
        vector<int> labels(n);
        int onesCount = 0;
        for (int i = 0; i < n; i++) {
            cin >> labels[i];
            if (labels[i] == 1) onesCount++;
        }
        
        for (int i = 1; i <= MAX_A; i++)
            parent[i] = i;
        
        for (int x : labels) {
            if (x == 1) continue;
            int temp = x;
            for (int p : primes) {
                if (p * p > temp) break;
                if (temp % p == 0) {
                    unionSets(x, p);
                    while (temp % p == 0) temp /= p;
                }
            }
            if (temp > 1) unionSets(x, temp);
        }
        
        unordered_set<int> roots;
        for (int x : labels) {
            if (x != 1) roots.insert(findRoot(x));
        }
        
        int components = roots.size() + onesCount;
        cout << "Case " << caseNum << ": " << components << "\n";
    }
    return 0;
}