Leetcode.2709 最大公约数遍历

题目链接

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

题目描述

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

你需要判断 n u m s nums nums 数组中任意两个满足 i < j i < j i<j 的下标 i i i 和 j j j ，是否存在若干次通行可以从 i i i 遍历到 j j 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 ≤ n u m s . l e n g t h ≤ 1 0 5 1 \leq nums.length \leq 10^5 1≤nums.length≤105
1 ≤ n u m s [ i ] ≤ 1 0 5 1 \leq nums[i] \leq 10^5 1≤nums[i]≤105

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

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

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

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

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

并查集参考

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

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

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

时间复杂度： O ( n × l o g n ) O(n \times logn) O(n×logn)

C++代码：

cpp 复制代码

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;

    }
};