Codeforces gym 101353 C 数论

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

摘要生成于 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;
}
Codeforces Gym 101630 是一场编程竞赛,通常包含多个算法挑战问题。这些问题往往涉及数据结构、算法设计、数学建模等多个方面,旨在测试参赛者的编程能力和解决问题的能力。 以下是一些可能出现在 Codeforces Gym 101630 中的题目类型及解决方案概述: ### 题目类型 1. **动态规划(DP)** 动态规划是编程竞赛中常见的题型之一。问题通常要求找到某种最优解,例如最小路径和、最长递增子序列等。解决这类问题的关键在于状态定义和转移方程的设计[^1]。 2. **图论** 图论问题包括最短路径、最小生成树、网络流等。例如,Dijkstra 算法用于求解单源最短路径问题,而 Kruskal 或 Prim 算法则常用于最小生成树问题[^1]。 3. **字符串处理** 字符串问题可能涉及模式匹配、后缀数组、自动机等高级技巧。KMP 算法和 Trie 树是解决此类问题的常用工具[^1]。 4. **数论与组合数学** 这类问题通常需要对质数、模运算、排列组合等有深入的理解。例如,快速幂算法可以用来高效计算大数的模幂运算[^1]。 5. **几何** 几何问题可能涉及点、线、多边形的计算,如判断点是否在多边形内部、计算两个圆的交点等。向量运算和坐标变换是解决几何问题的基础[^1]。 ### 解决方案示例 #### 示例问题:动态规划 - 最长递增子序列 ```python def longest_increasing_subsequence(nums): if not nums: return 0 dp = [1] * len(nums) for i in range(len(nums)): for j in range(i): if nums[i] > nums[j]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) # 示例输入 nums = [10, 9, 2, 5, 3, 7, 101, 18] print(longest_increasing_subsequence(nums)) # 输出: 4 ``` #### 示例问题:图论 - Dijkstra 算法 ```python import heapq def dijkstra(graph, start): distances = {node: float('infinity') for node in graph} distances[start] = 0 priority_queue = [(0, start)] while priority_queue: current_distance, current_node = heapq.heappop(priority_queue) if current_distance > distances[current_node]: continue for neighbor, weight in graph[current_node].items(): distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance heapq.heappush(priority_queue, (distance, neighbor)) return distances # 示例输入 graph = { 'A': {'B': 1, 'C': 4}, 'B': {'A': 1, 'C': 2, 'D': 5}, 'C': {'A': 4, 'B': 2, 'D': 1}, 'D': {'B': 5, 'C': 1} } start = 'A' print(dijkstra(graph, start)) # 输出: {'A': 0, 'B': 1, 'C': 3, 'D': 4} ``` #### 示例问题:字符串处理 - KMP 算法 ```python def kmp_failure_function(pattern): m = len(pattern) lps = [0] * m length = 0 # length of the previous longest prefix suffix i = 1 while i < m: if pattern[i] == pattern[length]: length += 1 lps[i] = length i += 1 else: if length != 0: length = lps[length - 1] else: lps[i] = 0 i += 1 return lps def kmp_search(text, pattern): n = len(text) m = len(pattern) lps = kmp_failure_function(pattern) i = 0 # index for text j = 0 # index for pattern while i < n: if pattern[j] == text[i]: i += 1 j += 1 if j == m: print("Pattern found at index", i - j) j = lps[j - 1] elif i < n and pattern[j] != text[i]: if j != 0: j = lps[j - 1] else: i += 1 # 示例输入 text = "ABABDABACDABABCABAB" pattern = "ABABCABAB" kmp_search(text, pattern) # 输出: Pattern found at index 10 ``` ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值