牛客竞赛数学专题班整数分解与筛法 题解

青蛙的约会

设跳了$t$​​次后两个青蛙相遇，即$x+(m\times t)\equiv y+(n\times t)(\mathrm{m}\mathrm{o}\mathrm{d}L)$。

方程可以转换成$(m-n)\times t+L\times u=(y-x)$。

根据裴蜀定理，可知方程$ax+by=m$有整数解时当且仅当$m$是$a$及$b$的最大公约数$d=\gcd (a,b)$​的倍数。

可以把无解的情况特判掉。

用扩展欧几里得定理可以求出原方程的通解，又因为题目要求第一次碰面，所以要求出$t$​​的一个最小正整数解。

详细的可以看oi-wiki，线性同余方程https://oi-wiki.org/math/number-theory/linear-equation/。

#include <bits/stdc++.h>
#define int long long
using namespace std;

int exgcd(int a, int b, int &x, int &y) {
    if (!b) {
        x = 1, y = 0;
        return a;
    }
    int x2, y2;
    int res = exgcd(b, a % b, x2, y2);
    x = y2;
    y = x2 - a / b * y2;
    return res;
}

int x, y, m, n, L;
int t, u, d;
int c;

signed main() {
    cin >> x >> y >> m >> n >> L;

    if (m - n > 0) {
        d = exgcd(m - n, L, t, u);
        c = y - x;
    } else {
        d = exgcd(n - m, L, t, u);
        c = x - y;
    }
    if ((y - x) % d) {
        cout << "Impossible";
        return 0;
    }
    t = t * c / d;
    cout << (t % (L / d) + (L / d)) % (L / d);

    return 0;
}

Sum of Consecutive Prime Numbers

$4\times 10^7$​​​内有$2433654$​​​个素数（可以用欧拉筛在$O(4\times 10^7)$的时间内求出）。

题目保证$T\le 1000,\sum n\le 4\times 10^7$​​​，

对于每次查询$n$​​​，可以用双指针维护连续的素数和，暴力的话是$2.4\times 10^6\times 10^3$​会超时，可以考虑减枝操作。

#include <bits/stdc++.h>
using namespace std;

const int N = 4e7 + 10;
int prime[N], vis[N], total;

void Prime() {	// 欧拉筛
    vis[1] = 1;
    for (int i = 2; i <= N - 10; i++) {
        if (!vis[i]) prime[++total] = i;
        for (int j = 1; j <= total && i * prime[j] <= N - 10; j++) {
            vis[i * prime[j]] = 1;
            if (i % prime[j] == 0) break;// 保证每个数只被筛一次
        }
    }
}

int main() {
    Prime();
    int T, n;
    scanf("%d", &T);
    while (T--) {
        scanf("%d", &n);
        int l = 1, r = 0, sum = 0, res = 0;
        while (r + 1 <= total && prime[r + 1] <= n) {	// 减枝
            while (r + 1 <= total && sum < n) {
                sum += prime[++r];
            }
            while (l <= r && sum > n) {
                sum -= prime[l++];
            }
            if (sum == n) res++, sum -= prime[l++];
        }
        printf("%d\n", res);
    }

    return 0;
}

Prime Distance

要找到$L$​​​​到$R(L<R\le 2147483647)$​​​​之间的所有素数，仅需用$\sqrt{ma{x}_R}=46340$​​​​以内的素数进行筛选就足够了。

又因为$\sum (R-L)\le 10^6$​​​​，因此可以用埃氏筛在$O(n\log \log n)$​的时间复杂度内筛出$[L,R]$​​内的质数。

注意：直接用memset会T掉。

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 46340 + 10;
const int M = 1e6 + 10;
const int inf = 0x3f3f3f3f;

int prime[N], vis[N], total;
int p[M];

void Prime() {
    for (int i = 2; i <= N - 10; i++) {
        if (!vis[i]) prime[++total] = i;
        for (int j = 1; j <= total && prime[j] * i <= N - 10; j++) {
            vis[i * prime[j]] = 1;
            if (i % prime[j] == 0) break;
        }
    }
}

int T, L, R;
signed main() {
    Prime();
    scanf("%lld", &T);
    while (T--) {
        scanf("%lld%lld", &L, &R);

        for (int i = 1; i <= total && prime[i] <= R; i++) {
            int w = (L + prime[i] - 1) / prime[i];
            for (int j = max(2LL, w); prime[i] * j <= R; j++)
                p[prime[i] * j - L] = 1;
        }

        vector<int> vec;  // 存储区间内的质数
        for (int i = L; i <= R; i++) {
            if (!p[i - L]) vec.push_back(i);
            p[i - L] = 0;
        }

        if (vec.size() <= 1) {
            printf("There are no adjacent primes.\n");
        } else {
            pair<int, int> minn = {inf, -1};
            pair<int, int> maxn = {-inf, -1};
            for (int i = 0; i < vec.size() - 1; i++) {
                if (vec[i + 1] - vec[i] > maxn.first) {
                    maxn.first = vec[i + 1] - vec[i];
                    maxn.second = i;
                }
                if (vec[i + 1] - vec[i] < minn.first) {
                    minn.first = vec[i + 1] - vec[i];
                    minn.second = i;
                }
            }
            printf("%lld,%lld are closest, %lld,%lld are most distant.\n",
                   vec[minn.second], vec[minn.second + 1], vec[maxn.second],
                   vec[maxn.second + 1]);
        }
    }
    return 0;
}

Prime Land

先求出$x=\prod p_i^{e_i}$，然后对$x-1$分解质因数并输出。

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 3e4 + 10;

int power(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res *= a;
        a *= a;
        b >>= 1;
    }
    return res;
}

int T, k, p[N], e[N];
int x, total;
signed main() {
    cin >> T;
    while (T--) {
        cin >> k;
        x = 1;
        for (int i = 1; i <= k; i++) {
            cin >> p[i] >> e[i];
            x *= power(p[i], e[i]);
        }
        x--;
        total = 0;
        int tmp = x;
        for (int i = 2; i * i <= x; i++) {
            int cnt = 0;
            while (tmp % i == 0) {
                tmp /= i;
                cnt++;
            }
            if (cnt) {
                p[++total] = i;
                e[total] = cnt;
            }
        }
        if (tmp > 1) {  // 自己是质数的情况
            p[++total] = tmp;
            e[total] = 1;
        }
        for (int i = total; i >= 1; i--)
            cout << p[i] << " " << e[i] << " \n"[i == 1];
    }

    return 0;
}

X-factor Chains

题目需要让序列$a$​​尽可能的长，且$a_i|a_{i+1}$，即$a_i\times t=a_{i+1}$只要让$t$尽可能小就行了，也就是$t$是一个质数。

对$x$​分解质因数得$x=p_1^{{\alpha }_1}{p}_2^{{\alpha }_2}...p_k^{{\alpha }_k}$​，即$a_{i+1}=a_i\times p_j$​，只需要将质因数$p_j$​​排列组合就行了。

可以注意到质因数的全排列是一个多重组合数，$S=\frac{(\sum {\alpha }_i)!}{\prod ({\alpha }_i!)}$。

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 3e4 + 10;

int T, fac[N];
int x, total, sum, res;

void init() {
    fac[0] = 1;
    for (int i = 1; i <= 100; i++) fac[i] = fac[i - 1] * i;
}

signed main() {
    init();
    cin >> T;
    while (T--) {
        cin >> x;
        sum = total = 0;
        int tmp = x;
        int w = 1;
        for (int i = 2; i * i <= x; i++) {
            int cnt = 0;
            while (tmp % i == 0) {
                tmp /= i;
                cnt++;
            }
            if (cnt) {
                sum += cnt;
                w *= fac[cnt];
            }
        }
        if (tmp > 1) sum++;
        res = fac[sum] / w;

        cout << sum << " " << res << endl;
    }

    return 0;
}