Leetcode.2584 分割数组使乘积互质

题目链接

Leetcode.2584 分割数组使乘积互质 rating ：2159

题目描述

给你一个长度为 $n$ 的整数数组 $nums$，下标从 $0$ 开始。

如果在下标 $i$ 处 分割 数组，其中 $0\le i\le n-2$ ，使前 $i+1$ 个元素的乘积和剩余元素的乘积互质，则认为该分割 有效 。

• 例如，如果 $nums=[2,3,3]$ ，那么在下标 $i=0$ 处的分割有效，因为 $2$ 和 $9$ 互质，而在下标 $i=1$ 处的分割无效，因为 $6$ 和 $3$ 不互质。在下标 $i=2$ 处的分割也无效，因为 $i=n-1$ 。

返回可以有效分割数组的最小下标 $i$ ，如果不存在有效分割，则返回 $-1$ 。

当且仅当 $gcd(va{l}_1,va{l}_2)=1$ 成立时，$va{l}_1$ 和 $va{l}_2$ 这两个值才是互质的，其中 $gcd(va{l}_1,va{l}_2)$ 表示 $val1$ 和 $val2$ 的最大公约数。

示例 1：

输入：nums = [4,7,8,15,3,5]
输出：2
解释：上表展示了每个下标 i 处的前 i + 1 个元素的乘积、剩余元素的乘积和它们的最大公约数的值。
唯一一个有效分割位于下标 2 。

示例 2：

 输入：nums = [4,7,15,8,3,5]
输出：-1
解释：上表展示了每个下标 i 处的前 i + 1 个元素的乘积、剩余元素的乘积和它们的最大公约数的值。
不存在有效分割。

提示：

• $n=nums.length$
• $1\le n\le 10^4$
• $1\le nums[i]\le 10^6$

解法：质因数分解 + 哈希表

我们要使 $va{l}_1和va{l}_2$ 互质，就是意味着 $va{l}_1和va{l}_2$ 分解质因数之后，它们各自的质因数之间没有交集，即没有相同的质因子。

我们先预处理出 $10^6$ 范围内的质数，将其存入 $primes$ 中，用 $min\_factor[x]$ 记录 $x$ 的最小质因子；

然后我们用哈希表 $sum$ 记录整个数组的质因数的个数，比如质因数 $p$ ，它的数量就是 $sum[p]$。

接着我们从 $0\le i<n-1$开始枚举每一个数组元素 $nums[i]$，用哈希表 $cnt$ 记录其质因数。

每当我们将一个元素 $nums[i]$ 的质因数记录到 $cnt$ 中，就开始判断($p$ 是 $nums[i]$ 的质因子)：

• 如果 $cnt[p]=0$，说明整个数组的质因子 $p$ 都应该在 $[i+1,n-1]$的范围内，当前 $[0,i]$不存在质因子 $p$，故 $i$ 是一个有效分割；
• 如果 $cnt[p]=sum[p]$，说明整个数组的质因子 $p$ 都应该在 $[0,i]$的范围内， $[i+1,n-1]$不存在质因子 $p$，故 $i$ 是一个有效分割；
• 如果 $cnt[p]>0andcnt[p]\ne sum[p]$，说明整个数组的质因子 $p$ 在 $i$ 的两侧，即 $[0,i]$ 和 $[i+1,n-1]$ 都存在，即当前 $i$ 不是一个有效分割；

时间复杂度： $O(U+nlogU)$

C++代码：

const int N = 1e6 + 10;
vector<int> primes;
int min_factor[N];

auto _ = []()
{
    vector<bool> st(N, true);
    for(int i = 2;i < N;i++)
    {
        if(st[i])
        {
            primes.push_back(i);
            min_factor[i] = i;
        }

        for(auto x:primes)
        {
            if(x * i >= N) break;
            st[i * x] = false;
            min_factor[i * x] = x;
            if(i % x == 0) break;
        }
    }

    return 0;
}();

class Solution {
public:
    int findValidSplit(vector<int>& nums) {
        int n = nums.size();
        unordered_map<int,int> sum, cnt;

        for(auto x:nums)
        {
            for(int i = x;i > 1;i /= min_factor[i])
            {
                sum[min_factor[i]]++;
            }
        }

        int mismatch = 0;
        auto fun = [&](int x)
        {
            int& k = cnt[x];
            if(k == 0)
            {
                if(++k != sum[x])
                {
                    mismatch++;
                }
            }
            else
            {
                if(++k == sum[x])
                {
                    mismatch--;
                }
            }

            return 0;
        };

        for(int i = 0;i < n - 1;i++)
        {
            auto x = nums[i];
            for(int j = x;j > 1;j /= min_factor[j])
            {
                fun(min_factor[j]);
            }

            if(mismatch == 0) return i;
        }

        return -1;
    }
};