Leetcode.2709 最大公约数遍历

题目链接

Leetcode.2709 最大公约数遍历 rating : 2172

题目描述

给你一个下标从 $0$ 开始的整数数组 $nums$ ，你可以在一些下标之间遍历。对于两个下标 $i$ 和 $j$（$i\ne j$），当且仅当 $gcd(nums[i],nums[j])>1$ 时，我们可以在两个下标之间通行，其中 $gcd$ 是两个数的 最大公约数 。

你需要判断 $nums$ 数组中 任意 两个满足 $i<j$ 的下标 $i$ 和 $j$ ，是否存在若干次通行可以从 $i$ 遍历到 $j$ 。

如果任意满足条件的下标对都可以遍历，那么返回 true ，否则返回 false 。

示例 1：

输入：nums = [2,3,6]
输出：true
解释：这个例子中，总共有 3 个下标对：(0, 1) ，(0, 2) 和 (1, 2) 。
从下标 0 到下标 1 ，我们可以遍历 0 -> 2 -> 1 ，我们可以从下标 0 到 2 是因为 gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1 ，从下标 2 到 1 是因为 gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1 。
从下标 0 到下标 2 ，我们可以直接遍历，因为 gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1 。同理，我们也可以从下标 1 到 2 因为 gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1 。

示例 2：

输入：nums = [3,9,5]
输出：false
解释：我们没法从下标 0 到 2 ，所以返回 false 。

示例 3：

输入：nums = [4,3,12,8]
输出：true
解释：总共有 6 个下标对：(0, 1) ，(0, 2) ，(0, 3) ，(1, 2) ，(1, 3) 和 (2, 3) 。所有下标对之间都存在可行的遍历，所以返回 true 。

提示：

• $1\le nums.length\le 10^5$
• $1\le nums[i]\le 10^5$

解法：质因数分解 + 并查集

如果 $gcd(nums[i],nums[j])>1$ 说明 $nums[i]$ 和 $nums[j]$ 之间一定存在至少一个相同的质因子。

所以我们可以直接预处理出 $[1,10^5]$ 内每个元素的质因数，记作$fac$。例如：$fac[10]$ 表示 $10$ 的所有质因数，即 { 2 , 5 } \{2, 5\} {2,5}。

我们可以将$nums$ 中的每一个元素都抽象成一个点，对应 $nums[i]$的质因数 $fac[nums[i]]$ 也抽象成若干点。

我们可以使用 并查集 ，将每一个元素 以及 他对应的质因数都合并到一起，表明他们是在一个集合中。如果有两个元素 $a,b$，都含有一个质因数 $p$，那么将 $a,p$合并，再将 $b,p$合并，最终 $a,b,p$ 都会在同一个集合中。接着我们就可以通过判断 $a$ 和 $b$ 是否在同一个集合中，来确定 $a,b$ 之间是否能通行。

并查集参考

为了方便操作，在合并 $(a,p)$时。由于质因数 $p$ 的范围也是在 $[1,10^5]$之间，为了避免和 $nums[i]$ 冲突，我们直接将 $p$ 映射到 $[1+n,n+p]$，这样就避免了冲突。

对于在合并 $(a,p)$ 的操作，就对应的变成了合并 $(a,n+p)$。

最后再遍历 $nums$，判断是否所有的元素都是在同一个集合中。这样才能保证，任何的 $(i,j)$ 之间都能通行。

时间复杂度：$O(n\times logn)$

C++代码：

const int N = 1e5 + 10;
vector<int> fac[N];

auto _ = []()
{
    for(int i = 2;i < N;i++)
    {
        auto x = i;
        for(int j = 2;j <= x / j;j++)
        {
            if(x % j == 0)
            {
                fac[i].push_back(j);
                while(x % j == 0) x /= j;
            }
        }

        if(x > 1) fac[i].push_back(x);
    }
    return 0;
}();


class Solution {
public:
    bool canTraverseAllPairs(vector<int>& nums) {
        int n = nums.size();
        int f[n + N + 1];
        memset(f, 0, sizeof(f));

        for(int i = 1;i <= n + N;i++) f[i] = i;

        function<int(int)> find_root = [&](int x)->int
        {
            if(f[x] != x) f[x] = find_root(f[x]);
            return f[x];
        };

        for(int i = 0;i < n;i++)
        {
            for(auto p:fac[nums[i]])
            {
                int x = find_root(i), y = find_root(n + p);
                //说明 i 和 n + p 已经是在同一个集合当中了，不需要再合并
                if(x == y) continue;
                f[x] = y;
            }
        }

        unordered_set<int> uset;

        //如果nums中的每一个元素 都在同一个集合中，那么他们的祖先节点都应该是相同的
        for(int i = 0;i < n;i++) uset.insert(find_root(i));

        return uset.size() == 1;

    }
};