清明培训清北学堂 DAY1

今天是李昊老师的讲授~~

总结了一下今天的内容：

1.高精度算法

（1）高精度加法

思路：模拟竖式运算

注意：进位

优化：压位

程序代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
char a1[1000],b1[1000];
int a[1000],b[1000],c[1000];
int main(){
scanf("%s",a1);
scanf("%s",b1);
int lena=strlen(a1);
for(int i=lena-1;i>=0;i--)a[lena-i]=a1[i]-'0';
int lenb=strlen(b1);
for(int i=lenb-1;i>=0;i--)b[lenb-i]=b1[i]-'0';
int lenc=max(lena,lenb);
for(int i=1;i<=lenc;i++)c[i]=a[i]+b[i]; //先将每一对应位加起来
for(int i=1;i<=lenc;i++){
c[i+1]+=c[i]/10; //进位
c[i]%=10;
}
while(c[lenc+1]>0) lenc+=1; //如果位数增多，则lenc++
for(int i=lenc;i>0;i--)
cout<<c[i];
return 0;
}

考虑负数的情况：

若只有一个负数，那么就成为正加数-另一个加数的形式；

若有两个负数，那么先算两个数的绝对值的和，再加上个负号‘-’；

（2）高精度减法

思路：模拟竖式运算，考虑进位

注意：结果为0的情况

程序代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
char a1[1000],b1[1000];
int a[1000],b[1000],c[1000];
int main(){
scanf("%s",a1);
scanf("%s",b1);
int lena=strlen(a1);
for(int i=lena-1;i>=0;i--)a[lena-i]=a1[i]-'0';
int lenb=strlen(b1);
for(int i=lenb-1;i>=0;i--)b[lenb-i]=b1[i]-'0';
int lenc=max(lena,lenb);
for(int i=1;i<=lenc;i++)c[i]=a[i]-b[i]; //先将每一对应位都相减，方便借位处理
for(int i=1;i<=lenc;i++){
if(c[i]<0) //若不够0，就向高位借位+10，高位--
{
c[i]+=10;
c[i+1]--;
}
}
while(c[lenc]==0) lenc--; //除去前导0
for(int i=lenc;i>0;i--)
cout<<c[i];
return 0;
}

考虑负数的情况：

若只有一个负数：

<1>负数-正数转化为两数绝对值相加，然后在前面加个负号‘-’；

<2>正数-负数转化为两数绝对值相加；

若有两个负数：

转化为被减数的绝对值-减数的绝对值；

！！！小数减大数de处理方法：

用大数减小数，然后在前面加上负号‘-’；

（3）高精度乘法

思路：模拟竖式运算，考虑进位

注意：结果为0的情况

程序代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
char a1[1000],b1[1000];
int a[1000],b[1000],c[1000];
int main(){
scanf("%s",a1);
scanf("%s",b1);
int lena=strlen(a1);
for(int i=lena-1;i>=0;i--)a[lena-i]=a1[i]-'0';
int lenb=strlen(b1);
for(int i=lenb-1;i>=0;i--)b[lenb-i]=b1[i]-'0';
int lenc;
for(int i=1;i<=lena;i++)
for(int j=1;j<=lenb;j++)
c[i+j-1]+=a[i]*b[j]; //对应位相乘
for(int i=1;i<lena+lenb;i++)
{
c[i+1]+=c[i]/10; //进位
c[i]%=10;
}
lenc=lena+lenb-1;
while(c[lenc+1]>0) lenc++; //如果位数增多，lenc++
for(int i=lenc;i>0;i--)
cout<<c[i];
return 0;
}

考虑负数的情况：

若有一个负数：正常绝对值相乘，前面加负号‘-’；

若有两个负数：正常绝对值相乘；

（4）高精度除法 ——高精除单精

思路：模拟竖式运算

程序代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
using namespace std;
char a1[1000];
int a[1000],b[1000],c[1000],b1;
int main(){
scanf("%s",a1);
cin>>b1;
int lena=strlen(a1);
for(int i=lena-1;i>=0;i--)a[lena-i]=a1[i]-'0';
for(int i=lena;i>0;i--){
c[i]=a[i]/b1;
a[i-1]+=(a[i]%b1)*10; 第lena位除以b1后的余数*10+第lena-1位的数继续除
}
while(c[lena]==0 && lena>0)lena--;
for(int i=lena;i>0;i--)printf("%d",c[i]);

return 0;
}

2.模意义下运算

例：

在模7意义下的运算：

3*3=9≡2 （mod 7）

4+5=9≡2 （mod 7）

4-5=-1≡6 （mod 7）

注意：无除法运算

那碰到除法的怎么办呢？？？

假设a*b=t（mod p）：

我们都知道费马小定理：

如果p是一个质数，而整数a不是p的倍数，则有a^（p-1）≡1（mod p）

t*a^（p-2）≡b （mod p）

t/a≡b （mod p）

so 模意义下/a相当于*a^（p-2）

模意义下运算的性质：

1.满足基本的交换律，分配率，结合律；

2.对中间结果取模不影响最终答案；

3.快速幂

首先让我们思考一下怎么求a^b%p？

有两种求法：

分治

简单说一下，就是要求a^b，那么我们就求a^(b/2)再平方就好啦，求a^(b/2)同理

快速幂

4.费马小定理

如果p是一个质数，而整数a不是p的倍数，则有a^（p-1）≡1（mod p）

应用：

计算组合数C（n，m）%（10^9+7）

C（n，m）=n!/（（n-m）！*m！）

=n!*（（n-m）！*m！）^（p-2）

=n!*（(（n-m）!)^（p-2）*(m！)^（p-2））

所以我们只要预处理任意n！，（n！）^（p-2）就好了

程序代码：

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pr;
const double pi=acos(-1);
#define rep(i,a,n) for(int i=a;i<=n;i++)
#define per(i,n,a) for(int i=n;i>=a;i--)
#define Rep(i,u) for(int i=head[u];i;i=Next[i])
#define clr(a) memset(a,0,sizeof a)
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
ld eps=1e-9;
ll pp=1000000007;
ll mo(ll a,ll pp){if(a>=0 && a<pp)return a;a%=pp;if(a<0)a+=pp;return a;} //模优化
ll powmod(ll a,ll b,ll pp){ll ans=1;for(;b;b>>=1,a=mo(a*a,pp))if(b&1)ans=mo(ans*a,pp);return ans;} //快速幂
ll read(){
ll ans=0;
char last=' ',ch=getchar();
while(ch<'0' || ch>'9')last=ch,ch=getchar();
while(ch>='0' && ch<='9')ans=ans*10+ch-'0',ch=getchar();
if(last=='-')ans=-ans;
return ans;
}
//head
ll b[110000],inv[110000];
int Q;
ll C(int n, int m){
if(n<m)return -1;
if(m==0 || m==n)return 1;
return b[n]*inv[n-m]%pp*inv[m]%pp; //求组合数，运用的组合数公式
}
int main(){
Q=read(); //看不懂的快读
pp=read();
b[0]=1;
rep(i,1,100000)b[i]=b[i-1]*i%pp; //算1~100000的阶乘
rep(i,1,100000)inv[i]=powmod(b[i],pp-2,pp); //算1！~100000！的逆元
cout<<C(5,2);
}

5.最大公约数，最小公倍数

求最大公约数可以用欧几里得算法

gcd（a，b）=gcd（b，a%b）；

这样我们就可以递归求最大公约数

我们知道一个定理：

两个数a，b的乘积等于的最大公约数gcd（a，b）与最小公倍数lcm（a，b）的乘积

那么我们就可以运用这个性质来就最小公倍数lcm（a，b）=（a*b）/gcd（a，b）

6.质数判别

（1） sqrt判别

对于每一个质数n，我们都可以从2枚举到√n，如果都不能整除n，则n为质数

时间复杂度为O（√n）

局限性：只能判断少量的数据

（2）埃氏筛

判断n以内的数有哪几个数是质数，我们可以从2到n判断：

如果当前数为质数，那么将n的范围内把当前数的所有倍数都标记为合数；

如果当前数为合数，那么将n的范围内把当前数及所有倍数都标记为合数；

时间复杂度为O（n loglogn）

小缺点：有些合数可能被标记过多次（例如6就被2和3标记过），还可以优化一下

（3）欧拉筛法——线性筛法

此筛法为埃氏筛的优化版，就是解决了一个数被多次标记的问题：

对于每一个合数，我们就让它被它最小的质因子标记一次

7.欧拉函数

是小于或等于n的正整数中与n互质的数的数目

若n，a为正整数，且n，a互素，则

欧拉定理

8.矩阵乘法

一个m*n的矩阵就是m*n个数排列成m行n列的一个数阵

一个m*p的矩阵A乘一个p*n的矩阵B 得到一个m*n的矩阵，其中：

例如：

所以我们只要对进行快速幂运算就好了

注意重载运算符，将*变为矩阵乘法，这样就可以快速幂啦

struct matrix{
int hang,lie;
lli data[101][101];
matrix() //我们给他一个构造函数初始化一下
{
hang=lie=0;
for (register int i=1;i<=100;i++)
for (register int j=1;j<=100;j++)
data[i][j]=0;
}
};

inline matrix operator * (const matrix &a,const matrix &b) //重载运算符，这样就可以将矩阵进行普通的快速幂运算了，核心!!!
{
matrix c; //作为矩阵乘法答案
c.hang=a.hang; //因为答案的行数是和a矩阵的行对齐的
c.lie=b.lie; //因为答案的列数是和b矩阵的列对齐的
for (register int i=1;i<=c.hang;i++) //枚举每一项进行相加
{
for (register int j=1;j<=c.lie;j++)
{
//累加操作，注意多进行几次mod
for (register int m=1;m<=a.lie;m++)
{
//枚举a矩阵的每一列,b矩阵的对应行数就不用管了
c.data[i][j]+=a.data[i][m]*b.data[m][j]%mod;
//理解一下就是c的第i行第j列就是a矩阵的i行的每一个数字和对应的b矩阵的
//第j列的每一个对应数字的乘积相加
//所以就是上面那个式子
c.data[i][j]%=mod;
}
}
}
return c;//完成乘法返回答案数组
}