Codeforces gym 101353 C 数论

最新推荐文章于 2022-09-21 14:56:44 发布

原创最新推荐文章于 2022-09-21 14:56:44 发布 · 609 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#codeforces

数论-质因子分解专栏收录该内容

4 篇文章

订阅专栏

本文介绍了一种通过质因数分解来计算一组数的最小公倍数的算法，特别适用于当数值较大且数量较多的情况。该算法首先进行质因数分解，并记录每个质因子的最大和次大指数，然后利用这些信息计算最终答案。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题意:

给定n个数, 每次操作可以选取一个a, 如果n个数中存在两个以上的数能被a整数, 那么n个数中所有能被a整除的数都要约去a这个因子,
直到不存在a可以继续操作….

求最终n个数的最小公倍数, mod 1e9 + 1

题解:

对于某个质因子p来说,n个数对其进行分解可以得到n个指数, 记其最大值为m1,次大值为m2, 那么最终n的贡献为p^(m2 - m1)

solution:
1. n<=3特判gcd
2. n > 3
分解质因子, 维护最大和次大值, 之后n个数中不为1的即是指数为1的质数, 排序,其中仅出现1次的对结果有贡献

code:

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

typedef long long ll;
const ll p = 1000000001;
const int N = 8001;

template <class T>
T read()
{
    T x = 0, f = 1; char ch = getchar();
    while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = 10 * x + ch - '0'; ch = getchar(); }
    return x * f;
}

ll a[100001];

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

template <class T>
struct Number_Theory
{
    ll pr[N / 5];
    bool jz[N];
    int cnt;
    void Euler_sieve()
    {
        memset(jz, true, sizeof jz);
        jz[1] = false;
        //  printf("ok\n");
        for (int i = 2; i < N; ++i)
        {
            if (jz[i])
            {
                pr[++cnt] = i;
                id[i] = cnt;
            }
            for (int j = 1; j <= cnt; ++j)
            {
                if (i * pr[j] >= N) break;
                T tmp = i * pr[j];
                jz[tmp] = false;
                if (i % pr[j] == 0)
                {
                    break;
                }
            }
        }
        //printf("ok\n");
        //  printf("ok\n");
    }
    int powp(ll &a, int b)
    {
        //  printf("1\n");
        int x = 0;
        while (a % b == 0) a /= b, ++x;
        return x;
    }
    void solve(ll a[], int len)
    {
        ll ans = 1;
        for (int i = 1; i <= cnt; ++i)
        {
            int mn = 0, mx = 0;
            for (int j = 1; j <= len; ++j)
            {
                if (a[j] < pr[i]) continue;
                int pw = powq(a[j], pr[i]);
                if (pw <= mn) continue;
                if (pw >= mx)
                {
                    mn = mx;
                    mx = pw;
                }
                else mn = pw;
            }
            ans = ans * qpow(pr[i], mx - mn) % p;
        }

        sort(a + 1, a + len + 1);
        a[0] = a[len + 1] = 0;
        for (int i = 1; i <= len; ++i)
            if (a[i] != a[i - 1] && a[i] != a[i + 1])
                ans = ans * a[i] % p;
        printf("%I64d\n", ans);
    }
    T qpow(T a, T b)
    {
        //  printf("1\n");
        T res = 1;
        while (b)
        {
            if (b & 1) res = res * a % p;
            a = a * a % p;
            b >>= 1;
        }
        //printf("12\n");
        return res;
    }

};
Number_Theory<ll>adrui;


int main()
{
    freopen("ce.in", "r", stdin);
    int n = read<int>();
    for (int i = 1; i <= n; ++i)
        a[i] = read<ll>();
    if (n <= 3)
    {
        if (n == 1) printf("%I64d\n", a[1] % p);
        else if (n == 2)
        {
            ll d = gcd(a[1], a[2]);
            a[1] /= d;
            a[2] /= d;
            a[1] %= p;
            a[2] %= p;
            printf("%I64d\n", a[1] * a[2] % p);
        }
        else
        {
            ll d = gcd(gcd(a[1], a[2]), a[3]);
            a[1] /= d;
            a[2] /= d;
            a[3] /= d;
            d = gcd(a[1], a[2]);
            a[1] /= d;
            a[2] /= d;
            d = gcd(a[2], a[3]);
            a[2] /= d;
            a[3] /= d;
            d = gcd(a[1], a[3]);
            a[1] /= d;
            a[3] /= d;
            a[1] %= p;
            a[2] %= p;
            a[3] %= p;
            printf("%I64d\n", a[1] * a[2] % p * a[3] % p);
        }
    }
    else
    {
    //  memset(adrui.t, 0, sizeof adrui.t);
        adrui.Euler_sieve();
        adrui.solve(a, n);
    }
    return 0;
}