合适数对

合适数对

给定一个长度为 $n$ 的正整数数列 $a_{1},a_{2}, \dots ,a_{n}$ 和一个正整数 $k$。

请你判断共有多少个数对 $\left( {l,r} \right)$ 同时满足：

• $1 \leq l < r \leq n$
• 存在一个整数 $x$ 使得 $a_{l} \times a_{r} = x^{k}$ 成立

输入格式

第一行包含两个整数 $n,k$。

第二行包含 $n$ 个正整数 $a_{1},a_{2}, \dots ,a_{n}$。

输出格式

一个整数，表示满足条件的数对的数量。

数据范围

前三个测试点满足 $2 \leq n \leq 10$。
所有测试点满足 $2 \leq n \leq {10}^{5}，2 \leq k \leq 100，1 \leq a_{i} \leq {10}^{5}$。

输入样例：

6 3
1 3 9 8 24 1

输出样例：

5

 

解题思路

　　这题需要用到算术基本定理。对于一个数$N = P_{1}^{\alpha_{1}} \cdot P_{2}^{\alpha_{2}} \cdot \cdots \cdot P_{n}^{\alpha_{n}}$，如果$N$是$k$次幂的话，那么就有$k \mid \alpha_{i}, \left( {i=1,2,\dots,n} \right)$，否则就至少存在一个$\alpha_{i}$，有$k \nmid \alpha_{i}$。因此这道题目就是要任意找两个数$a_{i}$和$a_{j}$，使他们的乘积$a_{i} \times a_{j}$的所有质因子的次幂都满足$k \mid \alpha_{i}$，问有多少对这种数。

　　我们枚举$j$，看$j$前面有多少个$a_{i}$使得$a_{i} \times a_{j}$满足条件。先把$a_{j}$进行质因数分解，得到$a_{j} = P_{1}^{\alpha_{1}} \cdot P_{2}^{\alpha_{2}} \cdot \cdots \cdot P_{n}^{\alpha_{n}}$，由于我们只关心质因数的次数是否为$k$的倍数，因此我们只需要关心质因数的次数模$k$后是否等于$0$。对于要找的$a_{i} = P_{1}^{\beta_{1}} \cdot P_{2}^{\beta_{2}} \cdot \cdots \cdot P_{n}^{\beta_{n}}$，应该满足$k \mid \left( \alpha_{i} + \beta_{i} \right)$（这是对应质因子的次数相加，如果具有不同的质因子，那么另一个数对应的次幂应该等于$0$，同样满足）。

　　由于每一个$a_{i} \leq {10}^{5}$，我们可以估算一下一个数可以最多分解到多少个不同的质因数，有$2 \times 3 \times 5 \times 7 \times 11 \times 13 \times 17 > {10}^{5}$，因此可以发现每个数最多可以分解到$6$个不同的质因子。因此每个数最多只有$6$个质因子的次幂需要补充为$k$的倍数。

　　对于$a_{j}$，我们找到它分解质因数后所有次幂不是$k$的倍数的质因子，假设为$P_{i}$，假设这些质因子的次幂模$k$后为$r_{i}$，容易发现$1 \leq r_{i} < k$。对于$a_{i}$，其质因数分解后与$a_{j}$相对应的$P_{i}$的次幂模$k$后为$t_{i}$，如果对于所有的$r_{i} + t_{i} = k$都满足，那么这个就是我们要找的$a_{i}$。补充：因为$1 \leq r_{i} < k, 1 \leq t_{i} < k$，$r_{i} + t_{i} < 2 \cdot k$，因此小于$2 \cdot k$且能被$k$整除的数就只有$k$。

　　我们可以直接用次幂模$k$后不为$0$的质因子的乘积进行哈希，例如上面的$P_{1}^{r_{1}} \cdot P_{2}^{r_{2}} \cdot \cdots \cdot P_{n}^{r_{n}}$，$P_{1}^{t_{1}} \cdot P_{2}^{t_{2}} \cdot \cdots \cdot P_{n}^{t_{n}}$。

　　AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int cnt[N];

LL power(int a, int b) {
    LL ret = 1;
    while (b--) {
        ret *= a;
        if (ret >= N) return 0; // 由于ai都满足<=1e5，因此大于1e5就没有意义了
    }
    return ret;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    
    LL ret = 0;
    while (n--) {
        int val;
        scanf("%d", &val);
        
        LL p = 1, q = 1;    // p表示对aj来说，次幂模k后不为0的质因子的乘积；q表示对于要找的ai，次幂互补的质因子的乘积
        for (int i = 2; i <= val / i; i++) {    // 对aj分解质因数
            int t = 0;
            while (val % i == 0) {
                t = (t + 1) % k;
                val /= i;
            }
            
            if (t) {    // 次幂不为0才需要相乘
                p *= power(i, t);       // i^t，累乘的结果必然不超过1e5
                q *= power(i, k - t);   // 相同质因子的次幂要互补，即i^(k-t)，累乘的结果可能超过1e5
                if (q >= N) q = 0;      // 超过1e5就没有意义了，赋值为0
            }
        }
        if (val > 1) {
            p *= val;
            q *= power(val, k - 1);
            if (q >= N) q = 0;
        }
        
        ret += cnt[q];
        cnt[p]++;
    }
    
    printf("%lld", ret);
    
    return 0;
}

　　上面的质因数分解的时间复杂度为$O \left( n \cdot \sqrt[]{n} \right)$。我们还可以用线性筛，因为线性筛可以得到每一个数的最小质因子，因此在分解质质因数时可以用最小质因子来进行分解，每一个数包含的质因子个数大约为$log~n$个，因此这种方法的时间复杂度为$O \left( n \cdot log~n \right)$的。

　　AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long LL;

const int N = 1e5 + 10;

int primes[N], cnt, minp[N];
bool vis[N];
int mp[N];

void get_prime(int n) {
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            primes[cnt++] = i;
            minp[i] = i;
        }
        for (int j = 0; primes[j] <= n / i; j++) {
            vis[primes[j] * i] = true;
            minp[primes[j] * i] = primes[j];
            if (i % primes[j] == 0) break;
        }
    }
}

LL power(int a, int b) {
    LL ret = 1;
    while (b--) {
        ret *= a;
        if (ret >= N) return 0;
    }
    return ret;
}

int main() {
    int n, k;
    scanf("%d %d", &n, &k);
    
    get_prime(N);
    
    LL ret = 0;
    while (n--) {
        int val;
        scanf("%d", &val);
        
        LL p = 1, q = 1;
        while (val > 1) {
            int t = minp[val], s = 0;
            while (val % t == 0) {
                s = (s + 1) % k;
                val /= t;
            }
            
            p *= power(t, s);
            if (s) q *= power(t, k - s);
            if (q >= N) q = 0;
        }
        
        ret += mp[q];
        mp[p]++;
    }
    
    printf("%lld", ret);
    
    return 0;
}

 

参考资料

　　AcWing 4319. 合适数对（AcWing杯 - 周赛）：https://www.acwing.com/video/3751/