第十五天（3）：素数筛法+分解素因数+整除问题

素数：只能被自身和1整除的大于1的正整数

T1

素数判定
时间限制:1 秒
内存限制:32 兆
特殊判题:否 :

题目描述：给定一个数 n,要求判断其是否为素数(0,1,负数都是非素数) 。

输入: 测试数据有多组,每组输入一个数 n。

输出: 对于每组输入,若是素数则输出 yes,否则输入 no。

样例输入:
13

样例输出:
yes

//
//  main.cpp
//  Prime_judge
//
//  Created by Apple on 2019/8/19.
//  Copyright © 2019 Apple_Lance. All rights reserved.
//

#include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;

bool judge(int n){
    if( n<=1 )
        return false;
    int bound = (int)sqrt(n) + 1;
    for(int i = 2;i <= bound;i++)
        if(n % i == 0)
            return false;
    return true;
}
    
int main(int argc, const char * argv[]) {
    // insert code here...
    int n;
    while(scanf("%d", &n) != EOF)
        printf(judge(n) ? "yes" : "no");
    return 0;
}

T2

素数
时间限制:1 秒
内存限制:32 兆
特殊判题:否

题目描述：输入一个整数 n(2<=n<=10000),要求输出所有从 1 到这个整数之间(不包括1 和数,
这个整数)个位为 1 的素数，如果没有则输出-1。

输入: 输入有多组数据。
每组一行,输入 n。

输出: 输出所有从 1 到这个整数之间(不包括 1 和这个整数)个位为 1 的素数(素数之间用空格隔开,最后一个素数后面没有空格),如果没有则输出-1。

样例输入:
100

样例输出:
11 31 41 61 71

//
//  main.cpp
//  Prime_Sieve
//
//  Created by Apple on 2019/8/19.
//  Copyright © 2019 Apple_Lance. All rights reserved.
//

#include <iostream>
#include <stdio.h>
using namespace std;

int prime[10000];
int primeSize;
bool mark[10000];

void init(){
    for(int i = 0;i<10000;i++)
        mark[i] = true;
    primeSize = 0;
    for(int i = 2;i < 10000;i++){
        if(mark[i] == false)
            continue;
        prime[primeSize++] = i;
        for(int j = i * i;j < 10000;j += i){
            mark[j] = false;
        }
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    int n;
    init();
    while(scanf("%d", &n) != EOF){
        bool isOutput = false;
        for(int i = 0;i<primeSize;i++)
            if(prime[i] < n && prime[i]%10 == 1){
                
                if(isOutput == false)
                {
                    isOutput = true;
                    printf("%d", prime[i]);
                }
                else
                    printf(" %d", prime[i]);
            }
        if(isOutput)
            printf("\n");
        else
            printf("-1\n");
    }
    return 0;
}

T3 分解素因数

$x = p_{1}^{e1} * p_{2}^{e2} * ... * p_{n}^{en}$

质因数的个数
内存限制:32 兆

题目描述:求正整数 N(N>1)的质因数的个数。
相同的质因数需要重复计算。如 120=22235,共有 5 个质因数。

输入: 可能有多组测试数据,每组测试数据的输入是一个正整数 N,(1<N<10^9)。

输出: 输出对于每组数据,输出 N 的质因数的个数。

样例输入: 120 样例输出: 5 提示: 注意:1 不是 N 的质因数;若 N 为质数,N 是 N 的质因数。

方法

利用素数筛法筛得 0 到 100000 区间内所有素数
输入 n
依次测试步骤1获得的素数是否能整除n，若能则表示该素数是n的一个素因子
不断将 n 除以该素数，知道不能整除为止，并统计幂指数，
若完成某素数的幂指数统计后， n 变为 1 ，则表明 n 的所有素因数全部都被分解出来了，分解活动提前终止
若遍历，测试，分解完所有预处理出来的素数， n 仍旧没有被除成 1 ，则表明 n 存在一个大于 100000 的因子，且该因子为其素因子，幂为 1

//
//  main.cpp
//  GCD
//
//  Created by Apple on 2019/8/19.
//  Copyright © 2019 Apple_Lance. All rights reserved.
//

#include <iostream>
#include <stdio.h>
using namespace std;

bool mark[100001];
int primeSize;
int prime[100001];

void init(){
    primeSize = 0;
    for(int i = 2;i<100000;i++){
        
        if(mark[i] == true)
            continue;
        
        prime[primeSize++] = i;
        
        if(i >= 1000)
            continue;
        
        for(int j = i * i;j < 100000;j += i)
            mark[j] = true;
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    init();
    int n;
//    printf("%d%d", prime[0], prime[1]);
//    printf(mark[2] ? "no":"yes");
    while(scanf("%d", &n) != EOF){
        int ansPrime[30];
        int ansSize = 0;
        int ansNum[30];
        for(int i = 0;i<primeSize;i++){
            if(n % prime[i] == 0){
                ansPrime[ansSize] = prime[i];
                ansNum[ansSize] = 0;
                while(n % prime[i] == 0){
                    ansNum[ansSize]++;
                    n /= prime[i];
                }
                ansSize++;
                if(n == 1)
                    break;
            }
        }
        if(n != 1){
            ansPrime[ansSize] = n;
            ansNum[ansSize++] = 1;
        }
        int ans = 0;
        for(int i = 0;i < ansSize;i++)
            ans += ansNum[i];
        printf("%d\n", ans);
    }
    return 0;
}

T4

整除问题
内存限制:32 兆
特殊判题:否
时间限制:1 秒

输入描述: 给定 n,a 求最大的 k,使 n!可以被 $a^k$ 整除但不能被 a^(k+1)整除。
输入: 两个整数 n(2<=n<=1000),a(2<=a<=1000) 输出: 一个整数.
例输入: 样6 10 样例输出: 1

分析

$x = p1^{e1} p2^{e2} ... pn^{en}$
$a^k = p1'^{e1' * k} p2'^{e2' * k} ... pn'^{en' * k}$

下确定最大的非负整数k，使a中任意素因素的幂指数k小于或等于该素因数在x中对应的幂指数大小
下确定n！中素因数p的幂指数：依次累加p的更高次的倍数能够再提供的素因子数，即每次向计数器累加 $\frac{n}{p^k}$ ，直到 $\frac{n}{p^k} == 0$ ，表示没有更多整数提供素因子


//
//  main.cpp
//  Divisible
//
//  Created by Apple on 2019/8/19.
//  Copyright © 2019 Apple_Lance. All rights reserved.
//

#include <iostream>
#include <stdio.h>
using namespace std;

bool mark[1001];
int primeSize;
int prime[1001];

void init(){
    primeSize = 0;
    for(int i = 2;i<1001;i++){
        if(mark[i])
            continue;
        mark[i] = true;
        prime[primeSize ++ ] = i;
        if(i > 100)
            continue;
        for(int j = i * i;j < 1001;j += i)
            mark[j] = true;
    }
}

int cnt1[1001];
int cnt2[1001];

int main(int argc, const char * argv[]) {
    // insert code here...
    int n, a;
    init();
    
    while(scanf("%d%d", &n, &a) == 2){
        for(int i = 0;i < primeSize;i++)
            cnt1[i] = cnt2[i] = 0;
        for(int i = 0;i < primeSize;i++){
            int t = n;
            while(t){
                cnt1[i] += t/prime[i];
                t = t/prime[i];
            }
        }
        int ans = 100000;
        for(int i = 0;i < primeSize;i++ ){
            while(a % prime[i] == 0){
                cnt2[i]++;
                a /= prime[i];
            }
            if(cnt2[i] == 0)
                continue;
            if(cnt1[i] / cnt2[i] < ans)
                ans = cnt1[i] / cnt2[i];
            
        }
        printf("%d\n", ans);
    }
    return 0;
}

lancecrazy

发布了182 篇原创文章 · 获赞 101 · 访问量 20万+

私信关注

第十五天（3）：素数筛法+分解素因数+整除问题

T1

T2

T3 分解素因数

方法

T4

分析

猜你喜欢