质数总结

最新推荐文章于 2024-05-31 09:44:20 发布
最新推荐文章于 2024-05-31 09:44:20 发布
阅读量132 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/sugewud/p/9819302.html
版权

poj 2689

要对数据敏感，L和R很大，但是L-R很小。

可以在（R - L）loglogR的时间内用筛法筛出所有质数。

然后扫一遍就好了。

有些细节要注意，有些地方会爆int，0和1不能算进去。

#include<cstdio>
#include<cstring>
#include<vector>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

typedef long long ll;
const int MAXN = 1e5 + 10;
const int MAXM = 1e6 + 10;
bool is_prime[MAXM];
vector<int> prime;
ll L, R;

void get_prime()
{
	memset(is_prime, true, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	REP(i, 2, MAXN)
	{
		if(is_prime[i]) prime.push_back(i);
		REP(j, 0, prime.size())
		{
			if(i * prime[j] >= MAXN) break;
			is_prime[i * prime[j]] = false;
			if(i % prime[j] == 0) break;
		}
	}
}

void work()
{
	memset(is_prime, true, sizeof(is_prime));
	REP(j, 0, prime.size())
	{
		int p = prime[j];
		int i = (L + p - 1) / p;
		if(i == 1) i++;
		for(ll k = (ll)i * p; k <= R; k += p)
			is_prime[k - L] = false;
	}
}

int main()
{
	get_prime();
	while(~scanf("%lld%lld", &L, &R))
	{
		work();
		int l1, r1, ans1 = 1e9, l2, r2, ans2 = 0;
		vector<int> ve;
		_for(i, 0, R - L)
			if(i + L >= 2 && is_prime[i])
				ve.push_back(i + L);
		
		if(ve.size() <= 1) puts("There are no adjacent primes.");
		else
		{
			REP(i, 1, ve.size())
			{
				int d = ve[i] - ve[i - 1];
				if(d < ans1)
				{
					ans1 = d;
					l1 = ve[i - 1];
					r1 = ve[i];
				}
				if(d > ans2)
				{
					ans2 = d;
					l2 = ve[i - 1];
					r2 = ve[i];
				}
			}
			printf("%d,%d are closest, %d,%d are most distant.\n", l1, r1, l2, r2);
		}
	}
	
	return 0;
}

bzoj 1607

用类似筛法的思想，每个数把它所有的倍数的答案都加1

可能有相同的数，所以要优化，可以预处理一下。

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 1e6 + 10;
int a[MAXN], b[MAXN];
int c[MAXN], num[MAXN], ans[MAXN], m, n;

int main()
{
	scanf("%d", &n);
	REP(i, 0, n)
	{
		scanf("%d", &a[i]);
		b[i] = a[i];
	}
	
	int t = 1;
	sort(b, b + n);
	REP(i, 0, n)
	{
		if(i > 0 && b[i] == b[i - 1]) num[m-1]++;
		else num[m] = 1, c[m++] = b[i];
	}
	REP(i, 0, m) ans[c[i]] = num[i] - 1;
	
	REP(i, 0, m)
	{
		int t = c[i];
		for(int j = 2; j * t <= c[m - 1]; j++)
			ans[j * t] += num[i];
	}
	REP(i, 0, n) printf("%d\n", ans[a[i]]);
	
	return 0;
}

「一本通 6.2 练习 1」质因数分解

超级大水题

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 1e5;
bool is_prime[MAXN];
vector<int> prime;
int n;

void get_prime()
{
	memset(is_prime, true, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	REP(i, 2, MAXN)
	{
		if(is_prime[i]) prime.push_back(i);
		REP(j, 0, prime.size())
		{
			if(i * prime[j] >= MAXN) break;
			is_prime[i * prime[j]] = false;
			if(i % prime[j] == 0) break;
		}
	}
}

int main()
{
	get_prime();
	scanf("%d", &n);
	
	REP(j, 0, prime.size())
		if(n % prime[j] == 0)
		{
			printf("%d\n", n / prime[j]);
			break;
		}
	
	return 0;
}

「一本通 6.2 练习 3」Goldbach's Conjecture

水水水

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 1e6 + 10;
bool is_prime[MAXN];
vector<int> prime;
int n;

void get_prime()
{
	memset(is_prime, true, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	REP(i, 2, MAXN)
	{
		if(is_prime[i]) prime.push_back(i);
		REP(j, 0, prime.size())
		{
			if(i * prime[j] >= MAXN) break;
			is_prime[i * prime[j]] = false;
			if(i % prime[j] == 0) break;
		}
	}
}

int main()
{
	get_prime();
	while(~scanf("%d", &n) && n)
	{
		bool ok = false;
		REP(j, 1, prime.size())
			if(is_prime[n - prime[j]])
			{
				printf("%d = %d + %d\n", n, prime[j], n - prime[j]);
				ok = true;
				break;
			}
		if(!ok) puts("Goldbach's conjecture is wrong.");
	}
	return 0;
}

「一本通 6.2 练习 4」Sherlock and His Girlfriend

一开始写的非常麻烦

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 1e5 + 10;
bool is_prime[MAXN];
vector<int> prime;
int n, ok;

inline bool check(int k) { return 2 <= k && k <= n + 1; }

void get_prime()
{
	memset(is_prime, true, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	REP(i, 2, n + 1)
	{
		if(is_prime[i]) prime.push_back(i);
		REP(j, 0, prime.size())
		{
			if(i * prime[j] > n + 1) break;
			is_prime[i * prime[j]] = false;
			if(check(i) && check(i * prime[j])) ok = 1;
			if(i % prime[j] == 0) break;
		}
	}
}

int main()
{
	scanf("%d", &n);
	get_prime();
    if(ok) printf("2\n");
	else printf("1\n");
	
    _for(i, 2, n + 1)
    {
    	if(is_prime[i]) printf("1");
    	else if(ok) printf("2");
    	printf("%s", i == n + 1 ? "\n" : " ");
	}
	return 0;
}

后来发现不用线性筛法代码会减少很多。并且只要n>2就输出颜色最少是2.

线性筛法的扩展性小一些，而普通筛法的扩展性大一些，可以延伸出一些东西。

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

const int MAXN = 1e5 + 10;
int s[MAXN], n;

int main()
{
	scanf("%d", &n);
    if(n > 2) printf("2\n");
	else printf("1\n");
	
    _for(i, 2, n + 1)
	    if(!s[i])
	    	for(int j = i * 2; j <= n + 1; j += i) s[j] = 1;
	
	_for(i, 2, n + 1)
	{
		if(!s[i]) printf("1 ");
		else printf("2 ");
	}
	
	return 0;
}

bzoj 2721

这道题我想了好久还是不会。

看题解的时候感觉特牛逼。

到底是怎么想到把y！转化成n！+t的

？？？？？

 

因为y > n!，所以设y = n！+t

代入可以求得

x = （n！）^2  / t +n!

所以答案就是n！的因子个数。

这个转化真的很秀。

那么怎么求呢？

首先因子个数为(c1 + 1)(c2+1)……(cn+1),c为质因数的幂

那么问题转化为怎么求质因数的幂

对于n！，质因数p的幂为n！ /  p + n！ / ( p*p) +n！ /  (p*p*p)

很好理解，把p的倍数的因子都有p，然后平方有两个，所以应该加上平方的，立方有三个……

代码是这样

		ll cnt = 0;
		while(t)
		{
			cnt += t / prime[j];
			t /= prime[j];
		}

然后呢，因为是n！的平方，所以每个因子的个数要乘以2.代入得

答案为（2*cnt1 + 1） * (2 * cnt2 + 1)……

这道题就解决了。

#include<bits/stdc++.h>
#define REP(i, a, b) for(register int i = (a); i < (b); i++)
#define _for(i, a, b) for(register int i = (a); i <= (b); i++)
using namespace std;

typedef long long ll;
const int MAXN = 1e6 + 10;
const int MOD = 1e9 + 7;
bool is_prime[MAXN];
vector<int> prime;
int n;

void get_prime()
{
	memset(is_prime, true, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	REP(i, 2, MAXN)
	{
		if(is_prime[i]) prime.push_back(i);
		REP(j, 0, prime.size())
		{
			if(i * prime[j] >= MAXN) break;
			is_prime[i * prime[j]] = false;
			if(i % prime[j] == 0) break;
		}
	}
}

int main()
{
	get_prime();
	scanf("%d", &n);
	
	ll ans = 1;
	REP(j, 0, prime.size())
	{
		int t = n;
		ll cnt = 0;
		while(t)
		{
			cnt += t / prime[j];
			t /= prime[j];
		}
		ans = ans * (cnt << 1 | 1) % MOD;
	}
	printf("%lld\n", ans);
	
	return 0;
}

 

转载于:https://www.cnblogs.com/sugewud/p/9819302.html

powerx_yc
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
求质数总结
计算机的艺术
12-04 6378
质数又称素数。指在一个大于1的自然数中，除了1和此整数自身外，没法被其他自然数整除的数。 一、判断一个数是否为质数 首先根据定义，最简单的判断一个数n是否为质数的方法，就是从2开始对小于n的所有数，依次判断是否能整除n，若都不能整除就是质数。 bool IsPrime(int n) { if(n == 1) return false; for(int i = 2; i < n;
质数筛总结
04-15
求质数的朴素算法(试除法, 埃式筛法),线性筛法(欧拉筛, 简易欧拉筛),高级筛法(增量式筛法, 分段式筛法),轮式筛法
【数论】 质数知识总结（质数判断、筛选、质因子分解、互质）
Qiuker_jl的博客
12-11 3367
文章目录一.定义二.质数的判断二.质数的筛选 一.定义 质数，又称素数，若一个正整数无法被除了1和它自身以外的其它数整除，则称其为质数，否则为合数。特殊地，1既不是合数也不是质数 二.质数的判断 试除法： 检查所有可能成为n的因子的数，若没有找到因子，则证明这个数是一个质数 一种朴素的做法就是从2遍历到N-1观察有无N的因子，若没有则说明N为质数，依据的想法是N的因子必然在1~N的范围内 改进： 其实我们只要找到一个N的因子（除了1和它本身）就可以证明N是个合数。 定理：如果N是一个合数，则必然存在一个N的
vj组队赛--质数的亲儿子题
qq_34035720的博客
11-11 298
G - Goodbye “Goodbye to the friends I’ve had, goodbye to my upstairs neighbor, goodbye to the kids downstairs, and anybody who lend me a favor.” “Or, goodbye to the positive proper divisor?” That game is popular these days. Two player take turns to choose
质数问题总结
11-14 1032
筛子法(sieve)求质数，算法书上如是说：前几年比较好的算法的复杂度为o(n),空间复杂度为o(n^(1/2)/logn).另外还有时间复杂度为o(n/logn),但空间复杂度为O(n/(lognloglogn))的算法。 另外，对于这样的筛法，还可以进一步优化，就是bool型数组里面只存奇数不存偶数。 第 1 步 把14个单元赋为true (每个单元代表的数是2*i+3,如第0单元代表3，
数论之质数筛法总结
weixin_30439067的博客
05-23 217
　　　　　　　　　　　　　　　　　数论之质数筛法 　 基本定义及性质： 　　质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数。 　 在整个自然数集合中，质数的数量不多，分布比较稀疏，对于一个足够大的整数N，不超过N的质数大约有 N/lnN 个,即每lnN个数中有一个质数。 　 质数的判断： 　 有一个简单而又暴力的算法...
素数总结
黄俊东的专栏
11-20 1436
本文转载自http://blog.csdn.net/neoxuhaotian/article/details/6172420 定义：除了1和其本身，没有其他约数的数。 测试：用n分别试除2到sqrt(n)的数，如果中间有一个能整除，即 为合数，否则即为素数 bool is_prime(int n)//判断n是否为素数，是素数返回1 {     int i;     boo
素数筛法总结.pptx
08-10
素数一般指质数。质数是指在大于1的自然数中，除了1和它本身以外不再有其他因数的自然数。质数只有两个正因数（1和自己）的自然数即为质数。比1大但不是素数的数称为合数。1和0既非素数也非合数。
使用Python判断质数(素数)的简单方法讲解
12-23
质数又称素数。指在一个大于1的自然数中，除了1和此整数自身外，不能被其他自然数整除的数。素数在数论中有着很重要的地位。... 前几天偶尔的有朋友问python怎么判断素数的方法，走网上查了查，总结了python脚本判断一
RSA过程总结
01-08
p:质数  q：质数 n：模   特性：p*q=n，n的长度为密钥的长度 第一步：计算n的欧拉函数o(n)=（p-1）*（q-1） 第二步：随机选取一个数e，要求 1<e<o(n),且e和o(n)为互质数（即两个只有一个公因子，该公因子...
c++ 程序 实例 总结 （质数完数素数水仙花数）
08-31
c++ 程序 实例 总结 （质数完数素数水仙花数）
素数基本结论及应用
06-13 1262
1. 定义及规定素数是只能被自身和 1 整除的正整数。 素数有无穷多个； 规定：1 不是素数； 规定：2 是素数中唯一的偶数； 最小的三个素数：2、3、5，可分别表示大拇指的大拇指的关节数，其他手指的关节数，以及手指的个数。
质 数
weixin_62224014的博客
02-13 351
1.定义 对大于1的自然数，只包含1和它本身两个约数（只能被1和它本身整除） 2.质数的判定——试除法 试除法判定质数 给定 n 个正整数 ai，判定每个数是否是质数。 输入格式 第一行包含整数 n。 接下来 n 行，每行包含一个正整数 ai。 输出格式 共 n行，其中第 i 行输出第 i个正整数 ai是否为质数，是则输出 Yes，否则输出 No。 数据范围 1≤n≤1001≤n≤100, 1≤ai≤231−11≤ai≤231−1 输入样例： 2 2 6 输出样例： ..
Lisp学习笔记1——打印素数
Small Flows
06-12 1275
(defun print-prime-number (&key (begin 2) (end 100)) (format t "prime number between ~d and ~d: " begin end) (format t "~{~d~t~}" (loop for i from begin to end when (loop for j from 2
数据结构——链式二叉树知识点以及链式二叉树数据操作函数详解！！
hu_ju_hong的博客
05-26 772
其实我们所说的三序其实就可以分为前序、中序、后序它们分别表示对一棵二叉树不同的遍历方式。我们在这里先对它们的遍历方式做一次●前序：根，左子树，右子树●中序：左子树，根，右子树●后序：左子树，右子树，根在这里，我们以如下的二叉树为例子进行三序的介绍：于是我们使用如下的代码在VS中直接手搓出上图的二叉树以方便我们后续对代码的检测。//二叉树节点}BTNode;//创建节点//创建二叉树//创建节点//将节点按照图示连起来//node1为根节点。
算法训练营day41
stmfresher的博客
05-27 365
动态规划理论基础（主要就是确定动态规划的几个步骤）
159.二叉树：二叉树的层平均值（力扣）
最新发布
weixin_63779802的博客
05-31 313
代码同样使用了广度优先搜索（BFS）的方法。主要思路是使用一个队列来进行层次遍历，在每一层遍历的时候，计算所有节点的值的总和以及节点的数量，然后用总和除以节点数量得到平均值。这个算法的时间复杂度是 O(n)，因为每个节点都会被访问一次，其中 n 是树中节点的数量。空间复杂度也是 O(n)，因为需要存储整个树的节点。代码是解决“二叉树的层平均值”问题的C++代码，这个问题要求计算二叉树中每一层的节点值的平均值，并返回一个包含这些平均值的列表。
一篇文章讲透排序算法之堆排序
duanku111的博客
05-27 455
在学习这篇文章之前，请大家先学习堆这一数据结构中堆的概念，向下调整算法，向下调整建堆。堆的实现堆排序就是利用堆里面学习过的知识点进行排序，如何进行排序呢？
二叉树间奏
chestnut_orenge的博客
05-30 447
已经学习过了二叉树的基础知识，那么间奏部分就来感受一下二叉树部分的OJ题吧。
用c语言循环实现输入10个正整数，统计输出其中素数（即质数）的个数的问题总结
05-31
非常感谢您的提问，以下是问题的总结： 1. 如何使用C语言循环实现输入10个正整数？ 答：可以使用一个循环来输入10个正整数，每次读入一个数字并存储到数组中。 2. 如何判断一个正整数是否为素数？ 答：可以使用一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值