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

总结了一下今天的内容：

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;//完成乘法返回答案数组
}

扩展：

例题1：

我们对原式进行化简：

这样我们只要算出A^3和A+A^2+A^3即可，方法就是上面的矩阵快速幂

例题2：

思路：我们可以将每一步看做是乘上一个矩阵，暂且叫这个矩阵为操作矩阵（具体什么矩阵根据有向图决定）

那么我们只要用一开始的矩阵data[A][B]*操作矩阵^k ，也就是要用到上面讲的矩阵快速幂啦

上三角矩阵

性质：平方后还是上三角矩阵；

分块矩阵

性质：平方后还是方块矩阵，且平方后对应位元素等于原位元素的平方；

对角矩阵

对称矩阵

9.n元一次方程组

举个例子：  三元一次方程组

将每一未知数的系数以及等号后的b写成一个矩阵

这样我们将x，y，z的系数都消成1，那么答案就显而易见了：

x=2；y=3；z=-1；

无解的情况

显然像这样就是无解的

无穷多解

像这样实质是一个方程的二元方程（就是不定方程）显然有无穷多个解

10.行列式

定义：

计算：

11.矩阵逆元

逆元的定义：

若矩阵B*A=I，则称B为A的左逆元

若矩阵A*B=I，则称B为A的右逆元

有逆元的前提： 矩阵的行列式不为0

如何求左逆元？？？

解：  设B*A=In      In为单位矩阵（单位矩阵的性质：单位矩阵乘任何矩阵都为原矩阵）

接下来我们对A矩阵的任何操作，同样对In也操作一次

那么当A变为I时，In变为B

证：当A=>I时，原式变为： I*B=？

显然矩阵In变为了矩阵B

12.矩阵树定理  印象开始模糊，甚至完全消失，允许我复制一波课件

扩展：k^2*logn求常系数线性递推方程

以斐波那契数为例：

洛谷2233

思路：我们知道到达D点是由C或E走过来的，我们不妨解决这个题的子问题：走n-1次正好走到C或E的方案数，且中途不经过D点

所以我们可以将路径看做是乘上下面的矩阵：

上面的1是表示可能到达A,B……E，第一行第一列代表A，第二行第二列代表B……依次类推

所以我们只要用矩阵快速幂求出这个矩阵^n-1次方就好啦

以上就是清北学堂第一天的内容啦！

内容好多啊QWQ