cf725d Another Problem About Dividing Numbers [分解质因数]

本文主要讨论了一道数学竞赛题目,涉及整数的除法操作和质因数分解。在给定a、b、k三个数的情况下,通过在每个回合中将a或b除以大于1的正整数c,探究能否恰好经过k次操作使a等于b。文章指出了在求解过程中易犯的错误,如忽视质数本身的约数个数、算法复杂度过高等,并提供了预处理质数和计算因子个数的方法。代码部分展示了如何利用这些方法解决该问题,但并未给出完整解决方案。

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

题意

给定 a , b , k a, b, k a,b,k, 在每一回合中,可以将 a 或 b 除以 c (c > 1)。问是否可以在恰好的 k 回合中使得 a = b a=b a=b

思路

这道题赛时写了二十五分钟,赛后写了三十五分钟,还是不够快。犯的错误如下:

  1. 求约数个数最后没有考虑这个数本身是质数,在循环最后少了 if(x > 1) ++ret;
  2. 没有考虑算法本身复杂度,求解质因数+T: O ( n T ) O(\sqrt n T) O(n T) 1 e 9 \sqrt {1e9} 1e9 大约是 1e5 !!!开方是对指数相除!
  3. calc(g)忘乘2了,记得要把全过程在纸上演算模拟一遍

知识

  1. 素数个数的上限:1-n的素数个数大约为 n / l n n n/lnn n/lnn
  2. 因子个数的上限: d ( n ) < O ( n ) d(n) < O(\sqrt n) d(n)<O(n ), 估计:1e12的数最多有5000个质因子
  3. 预处理 n \sqrt {n} n 的素数来分解质因数, O ( n l n n ) O(\sqrt {\dfrac{n}{lnn}}) O(lnnn )

代码

#include <cstdio>
#include <iostream>
#include <cstring>
#include <string>
#include <algorithm>
#include <cmath>
#include <vector>
#include <queue>
#include <map>
#include <stack>
#include <set>
#define NDEBUG
#include<assert.h>
using namespace std;
typedef vector<int> vi;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef unsigned int ui;

inline int read() {
    int x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9') {
        if(ch == '-') f = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    return x * f;
}

void chkmin(ll &x, ll y) {if(y < x) x = y;};
void chkmax(ll &x, ll y) {if(y > x) x = y;};

#define rep(i, a, n) for(int i = (a); i <= (n); ++i)
#define per(i, a, n) for(int i = (n); i >= (a); --i)
#define sz(v) ((int)(v).size())
#define all(x) (x).begin(),(x).end()
#define lowbit(x) (x) & (-x)
#define endl '\n'
#define rd read()
#define pb push_back
#define mst(a, b) memset((a), (b), sizeof(a));
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
#define ls (u << 1)
#define rs (u << 1 | 1)
#define mod ((int)1e9+7)
#define maxn (int)(1e5+5)

int t;
int a, b, k;

int cnt, prime[6000010];
bool vis[maxn];

void sieve(int n) {
    vis[1] = true;
    for(int i = 2; i <= n; ++i) {
        if(!vis[i]) prime[++cnt] = i;
        for(int j = 1; j <= cnt && i * prime[j] <= n; ++j) {
            vis[i * prime[j]] = true;
            if(i % prime[j] == 0) break;
        }
    }
}

int calc(int x) {
    if(x == 1) return 0;
    int ret = 0;
    rep(i, 1, cnt) {
        if(prime[i] > sqrt(x)) break;
        while(x % prime[i] == 0) ++ret, x /= prime[i];
    }
    if(x > 1) ++ret;
    return ret;
}

int main() {
    cin >> t;
    sieve(100000);
    while(t--) {
        a = rd, b = rd, k = rd;
        int g = __gcd(a, b);
        int mn = 2;
        if(a == g) --mn;
        if(b == g) --mn;
        int mx = calc(a / g) + calc(b / g) + calc(g) * 2;
        if(a == b && k == 1) {
            puts("No");
            continue;
        }
        if(mn <= k && k <= mx) puts("Yes");
        else puts("No");
    }
    return 0;
}
### Python 实现正整数分解质因数 为了实现将一个正整数分解成其质因数的功能,可以采用多种方法。下面展示一种简单而有效的方法来完成这一任务。 #### 方法一:迭代方式分解质因数 这种方法利用了质数的特性,从最小的质数2开始尝试除尽给定的整数,直到无法再被整除为止,接着增加试除的数值继续上述过程直至原数完全被分解[^1]。 ```python def decompose_prime_factors(number): factors = [] divisor = 2 while number > 1: while number % divisor == 0: factors.append(divisor) number //= divisor divisor += 1 formatted_output = f"{aa}=" + "*".join(str(factor) for factor in factors) return formatted_output if __name__ == "__main__": aa = int(input("请输入一个正整数: ")) result = decompose_prime_factors(aa) print(result) ``` 此代码段定义了一个名为`decompose_prime_factors` 的函数接收参数 `number`, 并返回字符串形式的结果表示输入数字等于各个质因子相乘的形式。当脚本作为主程序运行时会提示用户输入想要分解的正整数,并调用该函数处理后输出结果[^2]。 #### 方法二:优化后的迭代算法 考虑到效率问题,在实际应用中通常不会让divisor无限制增长而是设定合理的上限比如sqrt(n)+1, 同样也可以只考虑奇数从而减少不必要的计算次数。这里给出一段更高效的版本: ```python import math def optimized_decomposition(num): prime_factors = [] # Handle the case of dividing by 2 separately to make subsequent steps faster. while num % 2 == 0: prime_factors.append(2), num //= 2 # Check odd numbers up to sqrt(num). limit = int(math.sqrt(num)) + 1 for i in range(3, limit, 2): while (num % i == 0): prime_factors.append(i) num //= i if num > 2: prime_factors.append(num) output_string = str(aa)+"="+ '*'.join(map(str,prime_factors)) return output_string if __name__ == '__main__': aa=int(input('Enter an integer greater than one: ')) res=optimized_decomposition(aa) print(res) ``` 这段改进版不仅提高了性能还保持了良好的可读性和简洁性。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值