lightoj1341Aladdin and the Flying Carpet(分解质因数+dfs)

本文探讨了如何通过编程解决给定长方形面积后,寻找满足特定边界条件(长度和宽度不少于给定值)的不同组合数量的问题。通过分解质因数并采用剪枝策略优化算法效率,实现了一种有效解决方案。

题目链接:(http://lightoj.com/volume_showproblem.php?problem=1341)

题意大概就是给你一个长方形面积a,求满足长和宽都不少于b的情况数,长不等于宽,t(sqrt(a)-b)会爆,但是数据比较水没卡tsqrt(b),当然我是分解质因数然后暴力找约数xjb剪剪枝过的

#include <stdio.h>
#include<cmath>
#include<iostream>
#include<cstring>
using namespace std;
typedef long long LL;
bool is[1000010];
LL pri[100000];
LL cnt[100];
int nm[100];
LL b;
int siz=0,siz1=0;
int ans;
void isprime(){
    memset(is,0,sizeof(is));
    memset(pri,0,sizeof(pri));
    for(LL i=2;i<=1000000;i++){
        if(!is[i])pri[++siz]=i;
        for(int j=1;j<=siz&&i*pri[j]<=1000000;j++){
            is[i*pri[j]]=1;
            if(!(i%pri[j]))break;
        }
    }
}
void gao(LL a){
    LL mx=sqrt(a);
    memset(cnt,0,sizeof(cnt));
    memset(nm,0,sizeof(nm));
    cnt[1]=1;
    nm[1]=0;
    siz1=1;
    for(int i=1;i<=siz;i++){
        while((a%pri[i])==0){
            if(cnt[siz1]!=pri[i])cnt[++siz1]=pri[i];
            nm[siz1]++;
            a/=pri[i];
        }
        if(pri[i]>mx||pri[i]>a)break;
    }
}
void dfs(int pp,LL nw,LL mx){
    if(nw>mx)return ;
    if(pp>siz1){
        if(nw>=b)ans++;
        return ;
    }
    for(int i=0;i<=nm[pp];i++){
        dfs(pp+1,nw,mx);
        nw*=cnt[pp];

    }
}
int main(void)
{
    LL a;
    isprime();
    int t,cas=0;
    scanf("%d",&t);
    while(t--){
        scanf("%lld%lld",&a,&b);
        gao(a);
        ans=0;
        LL mx=sqrt(a);
        if(mx*mx==a)mx--;
        dfs(1,1,mx);
        printf("Case %d: %d\n",++cas,ans);
    }
    return 0;
}

顺带一提,tsqrt(b)的做法是分解质因数然后搞一搞就能得到约数的个数,然后暴力找不满足的,虽然复杂度有问题但是数据比较水还是能过的

<think>嗯,用户问的是如何对阶乘进行质因数分解,也就是n!的质因数分解算法。首先,我需要回忆一下相关的数学知识。阶乘的质因数分解,我记得应该涉及到每个质数在n!中的幂次。比如,n! = 2^a * 3^b * 5^c...这样,对吧?那具体怎么计算每个质数的指数呢? 哦,对了,Legendre定理。这个定理说,对于质数p,在n!中的幂次等于n除以p的整数部分,加上n除以p²的整数部分,直到商为零。公式就是$\sum_{k=1}^{\infty} \left\lfloor \frac{n}{p^k} \right\rfloor$。比如,求10!中2的幂次,应该是10//2=5,10//4=2,10//8=1,10//16=0,所以总和是5+2+1=8。对吧? 那算法步骤应该是这样的:首先,生成所有小于等于n的质数,然后对每个质数p,计算它在n!中的指数,最后把这些质数和对应的指数组合起来就是结果。那如何高效生成质数呢?可能需要用埃拉托斯特尼筛法,这样可以得到所有<=n的质数。 然后,对于每个质数p,循环计算n/p^k直到p^k超过n,累加这些商。这部分应该可以用循环来实现。比如,p从2开始,计算p^1, p^2,...,直到p^k >n,每次取n除以p^k的整数部分,加到指数里。 那具体实现的时候,需要注意效率问题。比如,预处理质数列表,避免重复计算。另外,分解质因数的时候,只需要处理质数,而不是所有数,这样能节省时间。 用户提供的引用里提到LightOJ 1035这个问题,应该和这个算法有关。可能题目需要处理多个测试用例,所以预处理质数表可能更高效。比如,先生成足够大的质数表,然后在每个测试用例中直接使用这些质数。 那在代码实现上,可能需要先写一个筛法生成质数,然后对于每个质数p,计算对应的指数。比如用Python的话,可以先写一个筛法函数,然后循环每个质数,计算指数。 举个例子,当n=5时,质数是2,3,5。计算2的指数:5//2=2,5//4=1,5//8=0,所以总共有3。3的指数是5//3=1,更高次方超过5,所以是1。5的指数是1。所以5! = 2^3 *3^1 *5^1。 那代码的大致结构应该是这样的: 1. 输入n。 2. 生成所有<=n的质数。 3. 对每个质数p,计算它在n!中的指数。 4. 输出结果。 比如,用Python的话,生成质数可以用埃氏筛。然后计算指数的部分可以用循环,直到p的幂超过n。 不过需要注意,当n=0或1时,n!是1,这时候质因数分解应该是空的,或者输出1=1?可能要看具体题目要求,但一般来说,n>=2的情况。 那用户可能想知道具体的步骤,所以应该分步骤说明,先找质数,再算每个的指数。然后给出代码示例,比如用Python实现。 另外,用户提供的引用中有提到输出格式,比如案例号,以及质数按升序排列,所以代码可能需要处理这些格式要求,但用户的问题可能更关注算法本身,所以代码示例可以简化。 可能的错误点:在筛法中忘记处理0和1的情况,或者在计算指数的时候循环条件错误,比如p^k没有及时更新,导致死循环。 此外,对于大数n,这样的算法是否高效?比如n很大时,质数列表可能会很大,但阶乘的质因数分解每个质数的处理是独立的,可能时间复杂度还是可以接受的,因为每个质数的处理次数是log_p(n),而质数的数量大约是n/ln(n)。所以总的时间复杂度大概是O(n)筛法时间加上O(n / log n) * log n) )=O(n)。这可能对于较大的n来说还是可行的,但具体要看题目中的n的范围。 总结,算法步骤是: 1. 找出所有小于等于n的质数。 2. 对每个质数p,计算其在n!中的指数,即sum_{k=1}^∞ floor(n/p^k)。 3. 输出质因数分解式。 然后,给出代码示例,例如用Python实现筛法和指数计算。同时,可能需要注意输出格式的问题,比如按升序排列质数,每个质数及其指数之间用*连接,如案例中的输出格式。 用户可能还会关心优化方法,比如预处理质数表,或者在计算指数时如何更高效。比如,当p超过n/2的时候,指数可能只有0或1,所以可以提前终止循环? 或者,在计算指数的时候,可以不用每次计算p^k,而是用不断乘以p的方法,直到超过n。比如: def get_exponent(n, p): count = 0 while p <= n: count += n // p p *= p return count 哦,不对,应该是这样: def get_exponent(n, p): count =0 current = p while current <=n: count += n//current current *= p return count 比如,对于p=2,n=10: current=2 →10//2=5 current=4 →10//4=2 current=8 →10//8=1 current=16 →停止,总和是5+2+1=8。正确。 所以这个循环是正确的。每次乘以p,而不是平方,这样对吗?比如,p的幂次是p^1, p^2, p^3,依次计算。所以current *=p,每次是p^k,比如第一次是p^1,然后p^2,p^3,直到超过n。是的。 那这样的话,函数可以正确计算指数。所以在代码中,对于每个质数p,调用这个函数即可。 那整个算法的大致流程就清晰了。现在需要将这些步骤转化为中文解释,分步骤说明,并给出代码示例和相关问题。</think>### 阶乘质因数分解算法分步说明 #### 1. 质数筛选 **目标**:找出所有小于等于$n$的质数。 **方法**:使用**埃拉托斯特尼筛法**(Sieve of Eratosthenes)[^3]。 **步骤**: - 初始化布尔数组`is_prime[0..n]`,默认标记为`True`。 - 将`is_prime[0]`和`is_prime[1]`设为`False`(0和1不是质数)。 - 从$p=2$开始遍历,若`is_prime[p]`为`True`,则将所有$p$的倍数标记为`False`。 - 最终所有标记为`True`的索引即为质数。 #### 2. 计算质数在$n!$中的幂次 **定理**:Legendre定理指出,质数$p$在$n!$中的幂次为: $$ \text{幂次} = \sum_{k=1}^{\infty} \left\lfloor \frac{n}{p^k} \right\rfloor $$ **步骤**: - 对每个质数$p$,计算$p^1, p^2, p^3, \dots$直到$p^k > n$。 - 将$\left\lfloor \frac{n}{p^k} \right\rfloor$累加,得到总幂次。 #### 3. 整合结果 将所有质数与对应的幂次按升序排列,得到$n!$的质因数分解形式: $$ n! = p_1^{a_1} \cdot p_2^{a_2} \cdot \dots \cdot p_k^{a_k} $$ --- ### 代码实现(Python) ```python def sieve(n): is_prime = [True] * (n + 1) is_prime[0:2] = [False, False] for p in range(2, int(n**0.5) + 1): if is_prime[p]: for multiple in range(p*p, n+1, p): is_prime[multiple] = False primes = [p for p, prime in enumerate(is_prime) if prime] return primes def factorial_prime_factorization(n): if n < 2: return "1 has no prime factors" primes = sieve(n) factorization = [] for p in primes: exponent = 0 current = p while current <= n: exponent += n // current current *= p factorization.append((p, exponent)) return factorization # 示例:分解5!的质因数 n = 5 result = factorial_prime_factorization(n) print(f"{n}! = " + " * ".join(f"{p}^{e}" for p, e in result)) # 输出:5! = 2^3 * 3^1 * 5^1 ``` --- ### 关键点解析 1. **筛法优化**:埃氏筛法的时间复杂度为$O(n \log \log n)$,适合$n \leq 10^6$的情况。 2. **幂次计算优化**:通过循环累加$\lfloor n/p^k \rfloor$,避免直接计算大数阶乘。 3. **输出格式**:质数按升序排列,符合数学规范[^4]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值