CF 1047 C Enlarge GCD gcd

题意: 给出N(<=3e5)个数, 每个数不超过M(<=1.5e7), 问最少去掉多少个能让这个数组的gcd变大, 不可能的话输出-1.

思路:

①: 题意等价于, 这个数列全都除以一开始的gcd, 得到B集合, 求B的最大子集C, 使得C的gcd不为1.

②: 而①又等价于: C集合中, 存在一个"公共质因子"X, 即C中每个数%X=0且X为质数.

③: 由②, 我们只需要统计每个质数是B中多少个数的因子, 求最大值就是C集合的大小CN. 答案就是N-CN.

下略证时间复杂度:

B中一个数Bi得到它的所有质因子:

Bi<=M, 所以其质因子<=sqrt(M)<4000, 而<4000的质因子共550个. 枚举前550个质数, 试除Bi. 我们又可以知道, 一个M以内的数, 最多有不超过20个不同的质因子(2*3*5*7*...), 所以其时间复杂度严格小于550.[1]

所以总复杂度严格小于(550+lg(M))*N≈1.5e8.

用map记录每个质数作为因子的次数.

代码:

#include<bits/stdc++.h>

using namespace std;

void debug_out() {
    cerr << '\n';
}

template<typename T, typename ...R>
void debug_out(const T &f, const R &...r) {
    cerr << f << " ";
    debug_out(r...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__);

typedef long long ll;

const int M = 2e7 + 5;
const int inf = 1e9 + 5;
const int mod = 1e9 + 7;

const int N = 3e5 + 5;


bool is_prime[M + 5];
int prime[M + 5], cnt = 0;// 素数个数

void jp() {
    fill(is_prime, is_prime + M, 1);
    is_prime[0] = is_prime[1] = 0;
    for (int i = 2; i <= M; ++i) {
        if (is_prime[i]) {
            prime[cnt++] = i;
        }
        for (int j = 0; j < cnt && prime[j] * i <= M; ++j) {
            is_prime[prime[j] * i] = 0;
            if (i % prime[j] == 0)
                break;
        }
    }
}


int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }

int n;
int a[M];

map<int, int> son;

void init() {
    scanf("%d", &n);
    jp();
    scanf("%d", &a[0]);
    int allgcd = a[0];
    for (int i = 1; i < n; i++) {
        scanf("%d", &a[i]);
        allgcd = gcd(allgcd, a[i]);
    }
    int flag = -1;
    for (int i = 0; i < n; i++) {
        if (a[i] != allgcd) {
            flag = 1;
            break;
        }
    }
    if (flag == -1) {
        printf("-1\n");
        return;
    }
    for (int i = 0; i < n; i++)a[i] /= allgcd;
    for (int i = 0; i < n; i++) {
        if (is_prime[a[i]])son[a[i]]++;
        else {
            int x = a[i];
            int pos = 0;
            while (x != 1 && !is_prime[x]) {
                if (x % prime[pos] == 0)son[prime[pos]]++;
                while (x % prime[pos] == 0)x /= prime[pos];
                pos++;
            }
            if (x != 1)
                son[x]++;
        }
    }
    int ans = n - 1;
    for (auto x:son) {
        ans = min(ans, n - x.second);
    }
    printf("%d\n",ans);
}


int main() {
    init();
    return 0;
}

[1]:参考, 素数拆分

      b、素数拆分
      给定一个数n，如何将它拆分成素数的乘积呢？
      还是用到上面讲到的试除法，假设 n = pm 并且 m>1，其中p为素数，如果p > sqrt(n)，那么根据算数基本定理，m中必定存在一个小于等于sqrt(n)的素数，所以我们不妨设p <= sqrt(n)。
      然后通过枚举[2, sqrt(n)]的素数，如果能够找到一个素数p，使得n mod p == 0（mod 表示取余数、也称为模）。于是m = n/p，这时还需要注意一点，因为m中可能也有p这个素因子，所以如果p|m，需要继续试除，令m' = m/p，直到将所有的素因子p除尽，统计除的次数e，于是我们得到了 n = (p^e) * n'，然后继续枚举素数对n'做同样的试除。
      枚举完[2, sqrt(n)]的素数后，得到表达式如图所示：

                                                               
      这时有两种情况：
      i)  S == 1，则素数分解完毕；
      ii) S > 1, 根据算术基本定理，S 必定为素数，而且是大于sqrt(n)的素数，并且最多只有1个，这种情况同样适用于n本身就是素数的情况，这时n = S。
      这样的分解方式称为因数分解，各个素因子可以用一个二元的结构体来存储。算法时间复杂度为O( s )，s为sqrt(n)内素数的个数。