数学知识()

已于 2024-03-24 20:05:22 修改
阅读量154 收藏
点赞数
文章标签： 算法 数学
于 2023-10-20 17:45:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74015873/article/details/133949365
版权

目录

质数

试除法判定质数

 分解质因数

 Divide and Equalize（cf）

筛质数

约数

试除法求约数(nlogm)

约数个数

 约数之和

欧拉函数

欧拉函数

 筛法求欧拉函数

快速幂

快速幂

快速幂求逆元 

质数

试除法判定质数

给定 n 个正整数 ai，判定每个数是否是质数。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个正整数 ai。

输出格式

共 n 行，其中第 i 行输出第 i 个正整数 ai 是否为质数，是则输出 Yes，否则输出 No。

数据范围

1≤n≤100
1≤ai≤2^31−1

输入样例：

2
2
6

输出样例：

Yes
No
#include<iostream>
using namespace std;
//试除法 O(sqrt(n))
bool prime(int x)
{
    if(x<=1) return false;
    for(int i=2;i<=x/i;i++)
    {
        if(x%i==0) return false;
    }
    return true;
}
int main()
{
    int n;cin>>n;
    while(n--)
    {
        int a;cin>>a;
        if(prime(a)) cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
    }
    return 0;
}

 分解质因数

给定 n 个正整数 ai，将每个数分解质因数，并按照质因数从小到大的顺序输出每个质因数的底数和指数。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个正整数 ai。

输出格式

对于每个正整数 ai，按照从小到大的顺序输出其分解质因数后，每个质因数的底数和指数，每个底数和指数占一行。

每个正整数的质因数全部输出完毕后，输出一个空行。

数据范围

1≤n≤100,
2≤ai≤2×10^9

输入样例：

2
6
8

输出样例：

2 1
3 1

2 3

x的质因子最多只包含一个大于根号x的数，如果有两个，两个质因数的乘积会大于x，矛盾

 i 从 2 遍历到 根号x。 用 x / i，如果余数为 0，则 i 是一个质因

s 表示质因子 i 的指数，x /= i 为 0，则 s++， x = x / i

最后检查是否有大于 根号x 的质因子，如果有，输出

#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
void divide(int x)
{
    for(int i=2;i<=x/i;i++)
    {
        int s=0;
        if(x%i==0)
        {
            while(x%i==0)
            {
                s++;
                x/=i;
            }
            printf("%d %d\n",i,s);
        }
    }
    if(x>1) printf("%d 1\n",x);
    printf("\n");
}
int main()
{
    int n;cin>>n;
    while(n--)
    {
        int x;cin>>x;
        divide(x);
    }
    return 0;
}

 Divide and Equalize（cf）

考点分解质因数

给出了一个由n个正整数组成的数组a。可以对其执行以下操作：选择一对元素ai和aj（1≤i，j≤n ，i≠j）；选择整数ai的除数之一，即整数x，使得ai mod x=0；将ai替换为ai/x，将aj替换为aj‧x。

通过应用一定次数的运算（可能为零）来确定是否可以使数组中的所有元素都相同。 

输入数据： 

7

5

100 2 50 10 1

3

1 1 1

4

8 2 4 2

4

30 50 27 20

2

75 40

2

4 4

3

2 3 1

输出数据： 

YES
YES
NO
YES
NO
YES
NO
#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
map<int,int>mp;
int main()
{
    int t;cin>>t;
    while(t--)
    {
    	int n;cin>>n;
    	mp.clear();
    	for(int i=1;i<=n;i++)
    	{
    		int x;cin>>x;
    		if(x==1) continue;
    		for(int j=2;j<=x/j;j++)
    		{
    			if(x%j==0)
    			{
    				while(x%j==0)
    				{
    					mp[j]++;
    					x/=j;
					}
				}
			}
			if(x>1) mp[x]++;
		}
		int flag=0;
		for(auto it:mp)
		{
			if(it.second%n!=0)
			{
				flag=1;
				break;
			}
		}
		if(flag) cout<<"NO"<<endl;
		else cout<<"YES"<<endl;
	}
	return 0;
}

#include<iostream>
#include<algorithm>
#include<cstring>
#include<map>
using namespace std;
const int N=1e4+10;
int a[N],b[N];
bool prime(int x)
{
	for(int i=2;i<=x/i;i++)
	{
		if(x%i==0) return false;
	}
	return true;
}
map<int,int>mp;
int main()
{
	int t;cin>>t;
	while(t--)
	{
		int n;cin>>n;
		for(int i=1;i<=n;i++) cin>>a[i];
		mp.clear();
		for(int i=1;i<=n;i++)
		{
			if(a[i]==1) mp[1]++;
			else
			{
				if(prime(a[i])) mp[a[i]]++;
				else
				{
					int num=a[i];
					for(int j=2;j<=num/j;j++)
					{
						if(num%j==0)
						{
							while(num%j==0)
							{
								mp[j]++;
								num/=j;
							}
						}
					}
					if(num>1) mp[num]++;
				}
			}
		}
			int flag=0;
		 for(auto t:mp)
		 {
		 	if(t.second%n!=0&&t.first>1)
		 	{
		 		flag=1;
		 		break;
			 }
		 }
			if(!flag) cout<<"YES"<<endl;
			else cout<<"NO"<<endl;
		
	}
	return 0;
}

筛质数

10000000（10^7）

最普通的筛法：1.606
埃及筛：0,316
线性筛：0.098
100000000（10^8）

最普通的筛法：28.134
埃及筛：3.756
线性筛：0.948

最普通的筛法 O(nlogn）

void Prime(int n)
{
    for(int i=2;i<=n;i++)
    {
        if(!st[i])prime[cnt++]=i;//把素数存起来
        for(int j=i;j<=n;j+=i) st[j]=1;//不管是合数还是素数都用来筛掉后面的数
    }
}

 埃氏筛法 O(nloglogn)

void Prime(int n)
{
    for(int i=2;i<=n;i++)
    {
        if(!st[i])
        {
            prime[cnt++]=i;//将素数存起来
            for(int j=i;j<=n;j+=i) st[j]=1;//用质数来筛掉后面的数
        }
        
    }
}

 线性筛法 O(n)

线性筛法用最小的质因数筛掉 不重复筛 只筛一遍 故O（n) 

void Prime(int n)
{
    for(int i=2;i<=n;i++)
    {
       if(!st[i]) prime[cnt++]=i;
       for(int j=0;prime[j]<=n/i;j++)//i*prime[j]<=n
       {
           st[prime[j]*i]=1;
           //1)当i%primes[j]!=0时,说明此时遍历到的primes[j]不是i的质因子，那么只可能是此时的primes[j]<i的
            //最小质因子,所以primes[j]*i的最小质因子就是primes[j];
            //2)当有i%primes[j]==0时,说明i的最小质因子是primes[j],因此primes[j]*i的最小质因子也就应该是
            //prime[j]，之后接着用st[primes[j+1]*i]=true去筛合数时，就不是用最小质因子去更新了,因为i有最小
            //质因子primes[j]<primes[j+1],此时的primes[j+1]不是primes[j+1]*i的最小质因子，此时就应该
            //退出循环，避免之后重复进行筛选。
           if(i%prime[j]==0) break;
       }
        
    }
}

#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e6+10;
int prime[N];
int st[N];
int cnt;
void Prime(int n)
{
    for(int i=2;i<=n;i++)
    {
       if(!st[i]) prime[cnt++]=i;
       for(int j=0;prime[j]<=n/i;j++)//i*prime[j]<=n
       {
           st[prime[j]*i]=1;
           if(i%prime[j]==0) break;
       }
        
    }
}
int main()
{
    int n;cin>>n;
    Prime(n);
    cout<<cnt<<endl;
    return 0;
}

约数

试除法求约数(nlogm)

给定 n 个正整数 ai，对于每个整数 ai，请你按照从小到大的顺序输出它的所有约数。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个整数 ai。

输出格式

输出共 n 行，其中第 i 行输出第 i 个整数 ai 的所有约数。

数据范围

1≤n≤100,
1≤ai≤2×10^9

输入样例：

2
6
8

输出样例：

1 2 3 6 
1 2 4 8 
for(int i=1;i<=x/i;i++)
    {
        if(x%i==0)
        {
            v.push_back(i);
            if(i*i==x) continue;
            else v.push_back(x/i);
        }
    }
#include<iostream>
#include<algorithm>
using namespace std;
const int N=1e8;
int a[N];
void print(int x)
{
    int cnt=0;
    for(int i=1;i<=x/i;i++)
    {
        if(x%i==0)
        {
            a[cnt++]=i;
            if(i*i==x) continue;
            else a[cnt++]=x/i;
        }
    }
    sort(a,a+cnt);
    for(int i=0;i<cnt;i++) cout<<a[i]<<" ";
    cout<<endl;
}
int main()
{
    int t;cin>>t;
    while(t--)
    {
        int n;cin>>n;
        print(n);
    }
}
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void print(int x)
{
    vector<int>v;
    for(int i=1;i<=x/i;i++)
    {
        if(x%i==0)
        {
            v.push_back(i);
            if(i*i==x) continue;
            else v.push_back(x/i);
        }
    }
    sort(v.begin(),v.end());
    for(int i=0;i<v.size();i++) cout<<v[i]<<" ";
    cout<<endl;
}
int main()
{
    int t;cin>>t;
    while(t--)
    {
        int n;cin>>n;
        print(n);
    }
}

约数个数

给定 n 个正整数 ai，请你输出这些数的乘积的约数个数，答案对 10^9+7 取模。

输入格式

第一行包含整数 n。

接下来 n行，每行包含一个整数 ai。

输出格式

输出一个整数，表示所给正整数的乘积的约数个数，答案需对 10^9+7 取模。

数据范围

1≤n≤100
1≤ai≤2×10^9

输入样例：

3
2
6
8

输出样例：

12

 N = (p1^x1)(p^x2)(p3^x3)…(pk^xk)，其中pi为质数。

则N的约数个数为：(x1+1)(x2+1)(x3+1)…(xk+1)

N中的约数

d=(p1^xx1)(p^xx2)(p^xx3)...(pk^xxk) ----(xx1<=x1 xx2<=x2...xxk<=xk)

乘法原理

#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
map<int,int>mp;
const ll mod=1e9+7;
int main()
{
    int t;cin>>t;
    while(t--)
    {
        int n; cin>>n;
        for(int i=2;i<=n/i;i++)
        {
            if(n%i==0)
            {
               while(n%i==0)
               {
                n/=i;
                mp[i]++;
               }
            }
        }
        if(n>1) mp[n]++;
    }
    ll sum=1;
    for(auto it:mp)
    {
        sum*=(it.second+1);
        sum%=mod;
    }
    cout<<sum<<endl;
    return 0;
}

 约数之和

给定 n 个正整数 ai，请你输出这些数的乘积的约数之和，答案对 10^9+7 取模。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个整数 ai。

输出格式

输出一个整数，表示所给正整数的乘积的约数之和，答案需对 109+7 取模。

数据范围

1≤n≤100,
1≤ai≤2×109

输入样例：

3
2
6
8

输出样例：

252

#include<iostream>
#include<algorithm>
#include<map>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
map<int,int>mp;
int main()
{
   int n;cin>>n;
   while(n--)
   {
       int x;cin>>x;
       for(int i=2;i<=x/i;i++)
       {
           if(x%i==0)
           {
               while(x%i==0)
               {
                   x/=i;
                   mp[i]++;
               }
           }
       }
       if(x>1) mp[x]++;
   }
   ll res=1;
   for(auto it:mp)
   {
       ll a=it.first,b=it.second;
       ll t=1;
       while(b--)
       {
           t=(t*a+1)%mod;
       }
       res=res*t%mod;
   }
   cout<<res<<endl;
   return 0;
}

 最大公约数----- __gcd(,)

最小公倍数 ----- 两数相乘/最大公约数


欧拉函数

欧拉函数

给定 n 个正整数 ai，请你求出每个数的欧拉函数。

输入格式

第一行包含整数 n。

接下来 n 行，每行包含一个正整数 ai。

输出格式

输出共 n 行，每行输出一个正整数 ai 的欧拉函数。

数据范围

1≤n≤100
1≤ai≤2×10^9

输入样例：

3
3
6
8

输出样例：

2
2
4

 

n * (1 - 1 / pi)-->n/pi*(pi-1) 

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
int main()
{
    int n;cin>>n;
    while(n--)
    {
        int x;cin>>x;
        ll res=x;
        for(int i=2;i<=x/i;i++)
        {
            if(x%i==0)
            {
                res=res/i*(i-1);
                while(x%i==0) x/=i;
            }
        }
        if(x>1) res=res/x*(x-1);
        cout<<res<<endl;
    }
}

 筛法求欧拉函数

给定一个正整数 n，求 1∼n 中每个数的欧拉函数之和。

输入格式

共一行，包含一个整数 n。

输出格式

共一行，包含一个整数，表示 1∼n中每个数的欧拉函数之和。

数据范围

1≤n≤10^6

输入样例：

6

输出样例：

12

 

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=1e6+10;
int primes[N],cnt;
int phi[N];
bool st[N];
int n;
void get_eulers(int n)
{
    phi[1]=1;
    for(int i=2;i<=n;i++)
    {
        if(!st[i])
        {
            primes[cnt++]=i;
            phi[i]=i-1;
        }
        for(int j=0;primes[j]<=n/i;j++)
        {
            st[primes[j]*i]=1;
            if(i%primes[j]==0)
            {
                phi[i*primes[j]]=primes[j]*phi[i];
                break;
            }
            else phi[i*primes[j]]=(primes[j]-1)*phi[i];
        }
    }
}
int main()
{
    cin>>n;
    get_eulers(n);
    ll res=0;
    for(int i=1;i<=n;i++) res+=phi[i];
    cout<<res<<endl;
    return 0;
}

快速幂

快速幂

#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
void qmi(int a,int b,int p)
{
    ll res=1;
    while(b)
    {
        if(b&1) res=res*a%p;
        b/=2;
        a=(ll)a*a%p;
    }
    cout<<res<<endl;
}
int main()
{
    int n;scanf("%d",&n);
    while(n--)
    {
        int a,b,p;
        scanf("%d%d%d",&a,&b,&p);
        qmi(a,b,p);
    }
    return 0;
}

快速幂求逆元 

#include <iostream>
using namespace std;
typedef long long LL;

LL qmi(int a, int b, int p)
{
    LL res = 1;
    while(b){
        if(b & 1) res = res * a % p;
        a = (LL)a * a % p;
        b >>= 1;
    }
    return res;
}

int main()
{
    int n; cin >> n;
    while(n --){
        int a, p;
        cin >> a >> p;
        if(a % p == 0) puts("impossible");
        else cout << qmi(a, p - 2, p) << endl;
    }
    return 0;
}

DHX～
关注
离散数学知识点
傅里叶变不出的博客
12-27 1万+
商集 定义： R 是 A 上等价关系，由 R 的所有等价类构成的集合称之为 A 关于 R 的商集。记作 A/R。 A/R={[a]R∣a∈A} A/R=\{[a]_R |a∈A\} A/R={[a]R​∣a∈A} 例如， A={1,2,3,4,5,6,7} , R是A上的模3同余关系，则$ A/R= {[1]_R ,[2]_R ,[3]_R } ={{1,4,7},{2,5},{3,6}}$ 由划分确定等价关系： 若A={A1,A2,…,An}A=\{A_1 ,A_2 ,…,A_n\}A={A1​,A2​
高中数学知识笔记大全.pdf
12-04
在数学领域，高中数学知识是学习数学的基石，涵盖了诸多重要的数学理论和公式。文件标题《高中数学知识笔记大全.pdf》就表明了这是一份系统整理的高中数学知识笔记，包括了函数、集合、数列、几何等基础数学分支，...
c++数学知识
skyflying266的博客
01-27 2685
数学知识 1.质数判定 2.质数筛选 —— 埃氏筛，线性筛 3.质因子分解. 4.试除法求约数，倍数法求约数 5.约数个数 6.约数和 7.最大公约数 8.欧拉函数，筛法求欧拉函数 质数 质数判定 暴力试除法 bool primes(int x){ for(int i=2;i<x;i++)if(x%2==0)return 0; return 1; }//O(N) 暴力优化 bool primes(int x){ for(int i=2;i<=x/i;i++)if(x%2
离散数学知识点总结
热门推荐
相似的人适合一起打闹
02-19 7万+
一、知识框架图 二、数理逻辑 1.命题符号化 命题：能判断真假的陈述句 命题包含两个要素：陈述句，能判断真假 命题题符号化的步骤： 1 )对于不太好理解的联结词或表达方式，如有必要,做适当的文字翻译。 2 )找出...
组合数学知识点汇总
傅里叶变不出的博客
12-22 4082
组合数学 第 1 章 排列、组合、二项式定理 1.2 排列与组合 1.2.1 集合的排列 注：r圆排列数不要和组合数搞混了 1.2.2 集合的组合 1.3 多重集合的排列与组合 1.3.1 多重集合的排列 1.3.2 多重集合的组合 注：这里是无限多重集合，2.2.1介绍了如何求任意重集合的r组合数 1.4 二项式定理 1.4.1 二项式定理的证明 1.4.2 二项式系数的基本性质 1.4.3 组合恒等式 1.4.4 多项式定理 1.5 集合的分划与第 2 类
高等数学知识点汇总
TianLiaoFeiJue的博客
07-03 5871
第一章 函数、极限与连续 1、函数的有界性 　　2、极限的定义(数列、函数) 　　3、极限的性质(有界性、保号性) 　　4、极限的计算(重点)(四则运算、等价无穷小替换、洛必达法则、泰勒公式、重要极限、单侧极限、夹逼定理及定积分定义、单调有界必有极限定理) 　　5、函数的连续性 　　6、间断点的类型 　　7、渐近线的计算 第二章导数与微分 1、导数与微分的定义(函数可导性、用定义求导数) 　　2、导数的计算(“三个法则一个表”：四则运算、复合函数、反函数，基本初等函数导数表;“三种类型”：幂指型、隐函数、参
算法常见数学知识
啷个哩个啷
11-16 4205
算法常见高数知识
学习人工智能必备数学知识详解
qq_34129320的博客
04-28 1009
学习人工智能需要掌握的数学知识丰富而多样，从线性代数、概率论与数理统计到优化理论、微积分等，都是构成人工智能知识体系的重要部分。同时，我们也要保持持续学习的态度，关注数学领域的新发展和新应用，不断提升自己的专业素养和能力水平。在学习线性代数时，需要掌握向量的基本运算、矩阵的乘法、逆矩阵、特征值和特征向量等概念，以及线性方程组的求解方法。在学习这部分内容时，需要掌握概率的基本概念、条件概率、贝叶斯定理等，以及常用的统计量、参数估计和假设检验等方法。这些知识在机器学习的分类、聚类、回归等任务中发挥着重要作用。
高等数学知识点整理
Gene_I must wait for the sunrise
04-22 3577
积分坐标变换
高等数学知识框架初步
wsdchong的博客
09-02 3973
高等数学知识框架初步 按照高聚合、低耦合的思路规划高等数学；让高等数学知识框架从易到难，从底层到上层， 首先说说前置知识。高等数学的前置知识是初等函数，即高中数学讲的内容； 然后讲讲核心内容。高等数学的核心内容是求极限、求微分、求积分。 最后讲讲应用。高等数学的应用包括几何应用等应用、中值定理、多元微分学、无穷级数。 文章目录高等数学知识框架初步按学习路线一、极限理论体系前言初等数学数列极限与函数极限无穷级数总结二、一元微分学理论体系前言一元微分学理论体系总结三、一元积分学理论体系前言一元积分理论体系总结四
密码学里的数学知识之
wushuai123_的博客
12-16 1508
计算机安全中，密码学涉及的数学知识 1 费马定理 费马定理： 若p是素数, gcd(a, p) = 1， 则 ap−1≡1 mod p或即: ap≡a mod p 则 \ a^p-1 ≡ 1\ mod\ p\\或即:\ a^p ≡ a \ mod\ p 则 ap−1≡1 mod p或即: ap≡a mod p 白话：若a,p互素，则a%p就等于a^p%p 注： gcd (a, p)
NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识（C).pdf
07-02
NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识 NOIP初赛 CSP-J1 CSP-S1 第1轮 初赛 信奥中的数学知识是指中国全国青少年信息学奥林匹克联赛（NOIP）的初赛数学知识，涵盖CSP-J1、CSP-S1两种级别的数学问题。...
最全面小学数学知识点精心总结大全(精华版).pdf
10-04
最全面小学数学知识点精心总结大全(精华版).pdf
最全面小学数学知识点最全总结(精华).pdf
10-04
最全面小学数学知识点最全总结(精华).pdf
代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数
Zuoriqiufeng的博客
10-30 391
【代码】代码随想录训练营Day12 | 110.平衡二叉树 - 257二叉树的所有路径 - 404.左叶子之和 - 222.完全二叉树的节点个数。
xtu oj 连接字符串
最新发布
Go offline for a while
10-30 959
最后总结一下：这题思路比较直观，找公共的元素，代码细节比较多，一个是要求输出字典序小的，第二是前面字符串要枚举完最后一个元素才算满足条件，第三是两个字符串可能完全没有公共部分，需要特判。
【力扣打卡系列】二分查找(搜索旋转排序数组)
qq_45734745的博客
10-29 290
坚持按题型打卡&刷&梳理力扣算法题系列，语言为go，Day11。
【算法】Kruskal最小生成树算法
Eristic0618的博客
10-29 718
算法学习笔记之Kruskal最小生成树算法
中学 数学 知识图谱 nlp
09-06
中学数学知识图谱NLP（自然语言处理）是指使用NLP技术来构建和应用中学数学知识图谱。数学知识图谱是一种将数学知识组织成图结构的方式，可以帮助学生和教师更好地理解和应用数学知识。 中学数学知识图谱NLP的主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值