看到高手的线性筛素数方法(Prime2函数):
const int N = 25600000;
bool a[N];
int p[N];
int n;
void Prime1() {
memset(a, 0, n * sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) if(!a[i]) {
p[num++] = i;
for(j = i+i; j < n; j +=i) {
a[j] = 1;
}
}
}
void Prime2() {
memset(a, 0, n*sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) {
if(!(a[i])) p[num++] = i;
for(j = 0; (j<num && i*p[j]<n); ++j) {
a[i*p[j]] = 1;
if(!(i%p[j])) break;
}
}
}
测试:
筛 [0, 100000) 范围内的素数
第一种素数筛法 0 毫秒
第二种素数筛法 0 毫秒
筛 [0, 200000) 范围内的素数
第一种素数筛法 15 毫秒
第二种素数筛法 0 毫秒
筛 [0, 400000) 范围内的素数
第一种素数筛法 16 毫秒
第二种素数筛法 15 毫秒
筛 [0, 800000) 范围内的素数
第一种素数筛法 47 毫秒
第二种素数筛法 16 毫秒
筛 [0, 1600000) 范围内的素数
第一种素数筛法 62 毫秒
第二种素数筛法 63 毫秒
筛 [0, 3200000) 范围内的素数
第一种素数筛法 297 毫秒
第二种素数筛法 109 毫秒
筛 [0, 6400000) 范围内的素数
第一种素数筛法 922 毫秒
第二种素数筛法 266 毫秒
筛 [0, 12800000) 范围内的素数
第一种素数筛法 2187 毫秒
第二种素数筛法 563 毫秒
筛 [0, 25600000) 范围内的素数
第一种素数筛法 4828 毫秒
第二种素数筛法 1187 毫秒
证明:任何一个合数只被标记一次。
可以试着执行下这个程序的流程,就明白了
怎么样 还行吧?
什么,觉得这个程序效率上没多大提升,没有什么用?
把a[]改成int类型,然后
void Prime2() {
memset(a, 0, n*sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) {
if(!(a[i])) p[num++] = i;
for(j = 0; (j<num && i*p[j]<n && (p[j]<=a[i]||a[i]==0)); ++j) {
a[i*p[j]] = p[j];
}
}
}
这样一来a[i]将记录i的最小质因子
那么[0, n)内的数的因式分解就可以... 嘿嘿
o(质因子个数)求任意数因式分解:
void factor(int x) {
while(a[x] != 0) {
printf("%d/n", a[x]);
x /= a[x];
}
printf("%d/n", x);
}
const int N = 25600000;
bool a[N];
int p[N];
int n;
void Prime1() {
memset(a, 0, n * sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) if(!a[i]) {
p[num++] = i;
for(j = i+i; j < n; j +=i) {
a[j] = 1;
}
}
}
void Prime2() {
memset(a, 0, n*sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) {
if(!(a[i])) p[num++] = i;
for(j = 0; (j<num && i*p[j]<n); ++j) {
a[i*p[j]] = 1;
if(!(i%p[j])) break;
}
}
}
测试:
筛 [0, 100000) 范围内的素数
第一种素数筛法 0 毫秒
第二种素数筛法 0 毫秒
筛 [0, 200000) 范围内的素数
第一种素数筛法 15 毫秒
第二种素数筛法 0 毫秒
筛 [0, 400000) 范围内的素数
第一种素数筛法 16 毫秒
第二种素数筛法 15 毫秒
筛 [0, 800000) 范围内的素数
第一种素数筛法 47 毫秒
第二种素数筛法 16 毫秒
筛 [0, 1600000) 范围内的素数
第一种素数筛法 62 毫秒
第二种素数筛法 63 毫秒
筛 [0, 3200000) 范围内的素数
第一种素数筛法 297 毫秒
第二种素数筛法 109 毫秒
筛 [0, 6400000) 范围内的素数
第一种素数筛法 922 毫秒
第二种素数筛法 266 毫秒
筛 [0, 12800000) 范围内的素数
第一种素数筛法 2187 毫秒
第二种素数筛法 563 毫秒
筛 [0, 25600000) 范围内的素数
第一种素数筛法 4828 毫秒
第二种素数筛法 1187 毫秒
证明:任何一个合数只被标记一次。
可以试着执行下这个程序的流程,就明白了
怎么样 还行吧?
什么,觉得这个程序效率上没多大提升,没有什么用?
把a[]改成int类型,然后
void Prime2() {
memset(a, 0, n*sizeof(a[0]));
int num = 0, i, j;
for(i = 2; i < n; ++i) {
if(!(a[i])) p[num++] = i;
for(j = 0; (j<num && i*p[j]<n && (p[j]<=a[i]||a[i]==0)); ++j) {
a[i*p[j]] = p[j];
}
}
}
这样一来a[i]将记录i的最小质因子
那么[0, n)内的数的因式分解就可以... 嘿嘿
o(质因子个数)求任意数因式分解:
void factor(int x) {
while(a[x] != 0) {
printf("%d/n", a[x]);
x /= a[x];
}
printf("%d/n", x);
}