王道机试第六章数学问题03

质数和质因子

质数（Prime Number）== 素数：只能被它自身和1整除的正整数
计算一个数是否是质数：
1.朴素算法：O(n)
2. 可以只枚举到根号n即可，原因：
例题：

代码：
1.注意如果使用long long，则输入格式“%lld”

//自己写：
#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;



int main(){
    int n;
    int tag;
    while(scanf("%d", &n) != EOF){      //根号运算返回值好像是double,添加头文件cmath
        tag = 0;
        for(int i = 2; i <= (int)sqrt(n); i++){
            if(n % i == 0){
                tag = 1;
                break;					//发现一个就退出
            }
        }
        if(tag){
            printf("false\n");
        } else {
            printf("true\n");
        }
    }
    return 0;
}
/*
 3139 2117
 49 14
 */

结果：运行超时:您的程序未能在规定时间内运行结束，请检查是否循环有错或算法复杂度过大。 case通过率为80.00%
注意：
1.小于2直接判定为no
2.sqrt（n）应该写<=，不是<
3.此处单独提出来写一个判断函数更好，要有这种思想
(20%找不到错误 老师的也是：)

#include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;


bool Judge(int n){
    if(n < 2){
        return false;
    }
    int bound = sqrt(n);
    for(int i = 2; i <= bound; i++){
        if(n % i == 0){
            return false;
        }
    }
    return true;
}

int main(){
    int n;
    while(scanf("%d" ,&n) != EOF) {
        if(Judge(n)){
            printf("yes\n");
        } else {
            printf("no\n");
        }
    }
    return 0;
}

如果是一组 数需要判断是否是质数，如果采用上诉方法时间复杂度为O(n*根号n),更好的方法：
质数筛法，例题

memset的使用方法还是不熟悉，记准确！

网上资料

`因为使用C++写小题目时经常需要清除数组，这里记录下Memset函数的sizeof运算符的使用注意。

 

memset的特点是：将给定地址后连续的内存(包括给定地址)，逐个byte初始化为参数中指明的值。

因为是逐byte初始化，所以memset一般只用来清空(赋值为0)

如果不赋值为0，结果是什么呢？假设对于int A[]，如果使用memset(A, 1, sizeof(A))，那么数组A的每一个值会被初始化为0x01010101

正因为如此，一般只会出现 memset(A, 0, sizeof(A))

对于堆区分配的数组，int *A = new int[N], memset(A, 0, sizeof(A[0])*N) 也可以达到效果，但要注意，这里第三个参数不能使用sizeof(A)，而要指明byte数。

要想知道原因，需要知道sizeof 运算符的作用。它返回的是“占用的栈空间字节数”。如果数组用int A[N]的形式申明，那么sizeof(A)返回的是整个A数组的占用byte数。如果用int *A = new int[N]，sizeof(A)返回的依旧是一个int *所占用的byte数，也就是说，32位编译器会返回 4，64位编译器会返回8。需要注意的是，对于两种编译器，sizeof作用在int *才会有区别，而sizeof(int) 或者 sizeof(a)  (a是一个申明为int的参数) 在两种编译器上都返回4。

下面是一个测试程序。编译环境为gcc 4.8.2 64-bit

int *B;
    int b;
    cout << "sizeof B: " << sizeof(B) << endl;  //8，因为我的编译器是64-bit
    cout << "sizeof b: " << sizeof(b) << endl; //4，无论32-bit还是64-bit编译器，int所占字节数都是4

    B = new int[5];
    B[4] = 7;
    B[3] = 6;
    B[2] = 5;
    B[1] = 3;
    B[0] = 1;

    cout << "-------B---------\n";
    for(i = 0; i < 5; ++i) cout << B[i] << ' '; //1 3 5 6 7
    cout << endl;
    memset(B, 0, sizeof(B));
    for(i = 0; i < 5; ++i) cout << B[i] << ' '; // 0 0 5 6 7 因为B 占了8字节，所以前8 byte置0
    cout << endl;

    int C[3];
    C[2] = 6;
    C[1] = 4;
    C[0] = 2;
    cout << "\n--------C--------\n";
    cout << "size of C: " << sizeof(C) << endl; //12，返回数组所占用的字节数
    for(i = 0; i < 3; ++i) cout << C[i] << ' '; //2 4 6
    cout << endl;
    memset(C, 0, sizeof(C));
    for(i = 0; i < 3; ++i) cout << C[i] << ' '; //0 0 0
    cout << endl;


知道了上面的原理，我们来看看二维数组的初始化。

int A[2][3] 对于这样的定义方式，我们依然可以通过memset(A, 0, sizeof(A))来完成对整个二维数组的初始化，因为这种方式申明的二维数组本质上还是一维排列。

如果是int **A，然后动态申明一个2*3的二维数组呢？我们可以像上面一样，通过 memset(A, 0, sizeof(A[0][0])*2*3) 来完成二维数组的初始化吗？

答案自然是不行。

动态分配的一维数组之所以依然能用Memset(虽然第三参数要指明byte数)来完成赋值，因为在堆区，一维数组的成员依然是连续排列。

而动态分配的二维数组中的int成员在堆区还是连续排列的吗？当然不是，既然不是，memset就不能得到想要的结果了。那实际结果是啥？memset会清空存放二级指针的连续内存，附带清除些别的内存区域。之后只要访问诸如A[0][1]之类的都会引发内存错误，因为二维数组的结构已经被破坏。

 

高维数组在初始化时的注意类似于二维数组，这里就不再赘述了。

我的代码：

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;

const int maxn = 10001;
//定义一个布尔型数组，下标是几就表示这个数是几，数组值：true没有扫过的地方，false是非质数

bool Judge(int n){
    int bound = sqrt(n);
    if(n < 2){
        return false;
    } else{
        for(int i = 2; i <= bound; i++){
            if(n % i == 0){
                return false;
            }
        }
        return true;
    }
}

int main(){
    bool A[maxn];
    vector<int> B;  //用于存储质数
    fill(A,A+maxn,true);
    for(int i = 2; i < maxn; i++){
        if(A[i] == true){//目前还没排除怀疑的需要进行验证
            //先把它所有倍数都置为非质数
            for(int j = 2;i*j <= maxn;j++){
                A[i*j] = false;
            }
            //验证i是否为质数
            if(Judge(i)){
                B.push_back(i);
            }
        }
    }
    int k;
    while (scanf("%d",&k) != EOF){
        printf("%d\n",B[k-1]);
    }

    return 0;
}
/*

 */
 您的代码已保存
答案错误:您提交的程序没有通过所有的测试用例
case通过率为33.33%

用例:
9384

对应输出应该为:

97577

你的输出为:
0

解决方法：改大maxn即可，但是目前不知道怎么看内存和运行时间