NOIP复习之1 数学数论

noip一轮复习真的要开始啦！！！

大概顺序是这样的

1.数学

2.搜索贪心

3.数据结构

4.图论

5.dp

6.其他

　　　　　　　　　　　　　　　　数学

1.数论

数论被称为数学皇冠上的明珠，他的重要性主要在于它是其他学习的祖师，基本上什么代数问题都可以通过数论推导，其实有的图论也是（数学上）。

我们信息中的数论主要是说对整除同余的研究~~~~~~~

①：唯一分解定理与素数

这个之前我们先要讲素数（定义全部掠过）

素数筛法：

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int prime[1000100],phi[1000100],n,m,k,l,a,b;
bool isprime[1000100];
void shai()
{
    int sum=0;
    memset(isprime,0,sizeof(isprime));
    memset(prime,0,sizeof(prime));
    for(int i=2;i<=n;i++)
    {
        if(!isprime[i])
        {
            prime[sum++]=i;
            phi[i]=i-1;
        }
        for(int j=0;j<sum&&prime[j]*i<=n;j++)
        {
            isprime[prime[j]*i]=1;
            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else
            {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
} 
int main()
{
    phi[1]=1;
    cin>>n;
    shai();
    for(int i=0;i<=n;i++)
    cout<<phi[i]<<" ";
    return 0; 
}

这里面也有一个叫phi的东西。。。我们一会再说。

筛好以后我们就可以根绝唯一分解定理分解素数

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
int prime[10000100],phi[10000100],cut[10000100][3],num=0,n,m,k,l,a,b;
bool isprime[10000100];
void shai()
{
    int sum=0;
    memset(isprime,0,sizeof(isprime));
    memset(prime,0,sizeof(prime));
    for(int i=2;i<=10000000;i++)
    {
        if(!isprime[i])
        {
            prime[sum++]=i;
            phi[i]=i-1;
        }
        for(int j=0;j<sum&&prime[j]*i<=n;j++)
        {
            isprime[prime[j]*i]=1;
            if(i%prime[j]==0)
            {
                phi[i*prime[j]]=phi[i]*prime[j];
                break;
            }
            else
            {
                phi[i*prime[j]]=phi[i]*(prime[j]-1);
            }
        }
    }
} 
int main()
{
    phi[1]=1;
    shai();
    cin>>m;
    for(int i=0;i<=10000000;i++){
        if(m==1)break;
        while(m%prime[i]==0)m/=prime[i],cut[i][1]=prime[i],cut[i][2]++;
    }
    for(int i=0;i<=1000;i++){
        if(cut[i][1]!=0)
        cout<<cut[i][1]<<" "<<cut[i][2]<<endl;
    }
    return 0; 
}

省选之后我们发现o跟下n求一个数的唯一分解是不够的

于是就有了miller rabin。

这个东西是根据那个费马小定理（欧拉定理）的p为素数的条件进行的素数测试。

这个东西有个兄弟叫rho

这个东西是用来解决找合数因子的

把主程序里的不断除m改为知道miler检测到为素数为止。

好了那么我们就可以对10^18次方之内的进行分解了（noip只会考on）

那么有什么用呢？

我们把分解后的表示为π（ai^pi）

1.因子数：π（pi+1）；

2.因子和：这个很有意思：

ans=(1+p1^1+p1^2+......+p1^a1)(1+p2^1+p2^2+......+p2^a2)(1+p3^1+p3^2+......+p3^a3)......(1+pn^1+pn^2+......+pn^an)

=π(1-pi^ai)/(1-pi);

这个东西逆元就行。

②快速幂（模数的最广泛应用（二进制））

//ksm
 #include<iostream>
 #include<cstdio>
 #include<algorithm>
 #include<queue>
 #include<stack>
 #include<fstream>
 #include<cstring>
 using namespace std;
 #define ll long long
 ll qpow(ll a,ll x)
 {
     ll base=a,ans=1;
     for(;x>0;x>>=1)//简单办法 
     {if(x&1)
         ans*=base;//当为奇数叠加求解 
         base*=base;
     }
     return ans;
 } 
  int main()
 {
     //freopen(".in","r",stdin);
     //freopen(".in","r",stdin);
     ll a,b;
     cin>>a>>b;
     cout<<qpow(a,b);
     return 0;
 }

这个东西根据费马小定理可以求逆元

方法是a^(mod-2)=a^(-1)mod mod;

快速乘其实是龟速乘

利用二进制实现调整中途溢出long long的膜意义下乘法

也是利用二进制表示

 这样就可解决10^18次方的两个数在%意义下的乘法取模

（其实它是log length的复杂度，并不快，只是比n个相加取模要快（传统防止溢出）所以不是像noi2018龙和勇士那种问题不要乱用）

#include<iostream>
#define mod 1000000007
#define ll long long
using namespace std;
ll ksc(ll a,ll b){
    ll ans=0,base=a;
    for(;b;b>>=1){
        if(b&1)ans=(ans+base)%mod;
        base=base*2%mod;
    }
    return ans;
}
ll a,b; 
int main(){
    cin>>a>>b;
    cout<<ksc(a,b);
    return 0;
} 

 

③exgcd gcd

gcd太熟悉了现打一个

long long gcd(long long a,long long b){
    return !b?a:gcd(b,a%b);
}

exgcd也差不多 exgcd也可以求逆元的，这个定义式推。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int gcd(int a,int b)
{
    return b==0?a:gcd(b,a%b);
}
void exgcd(int a,int b,int &d,int &x,int &y)
{
    if(!b){d=a;x=1;y=0;return ;}
    exgcd(b,a%b,d,y,x);
    y-=(a/b)*x;
}
int main ()
{
    int m,n,k;
    cin>>m>>n>>k;
    int gc=gcd(n,m);
    m/=gc;n/=gc;
    k/=gc;
    int x,y,d;
    cout<<m<<"x+"<<n<<"y="<<gc<<endl;
    exgcd(m,n,d,x,y);
    cout<<x<<" "<<y<<endl<<d<<endl<<endl;
    for(int i=1;i<=10;i++)
    {
        x+=(n)*i;
        y-=(m)*i;
        cout<<x<<" "<<y<<endl;
    }
    return 0;
}

④excrt。crt

excrt 在noip是在不大可能考，要考也是t3的最后一部分，毕竟noi t1难度不是盖的（当时本蒟蒻只拿了三十分那个题。。。。）

#include<iostream>
#include<cstdlib>
#include<ctime>
#include<cstdio>
#include<cstring>
using namespace std;
long long m[100000],ma[100000],a[100000],c,mall=1,ansx;
long long qpowmod(long long a,long long x,long long p)
{
    long long base=a,ans=1;
    for(;x>0;x>>=1){
        if(x&1)
        ans*=base,ans%=p;
        base*=base,base%=p;
    }
    return ans%p;
}
int main()
{
    
    cin>>c;
    for(int i=1;i<=c;i++){
        cin>>a[i]>>m[i];
        mall*=m[i];
    }
    for(int i=1;i<=c;i++){
        ma[i]=mall/m[i];
    }
    for(int i=1;i<=c;i++){
        ansx+=a[i]*ma[i]*qpowmod(ma[i],m[i]-2,mall);
        ansx%=mall;
    }
     
    cout<<mall<<endl<<ansx<<endl;
} 

excrt的话就是加一个exgcd就行。

 

另外 我们需要利用bezout解决问题比如小凯的疑惑

几个简单而熟知的结论

(a,b)=(a+b,b)=(a-b,b)

ax+by=(a,b) x,y∈z

 

 

2.计算几何

计算几何noip要是考也是向量题，最多带个凸包。

①向量点积a2b1-a1b2

②凸包：这个东西在斜率优化那里有（那里是个上凸壳），大概是完全一样的。栈维护进出

保证点积>0

#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
using namespace std;
struct node{
    double x,y;
}p[10005],s[10005];
int n;
double ans,mid;
double CJ(node a1,node a2,node b1,node b2)
{
    return (a2.x-a1.x)*(b2.y-b1.y)-(b2.x-b1.x)*(a2.y-a1.y);
}
double dis(node p1,node p2)
{
    return sqrt( (double)(p2.y-p1.y)*(p2.y-p1.y)*1.0+(double)(p2.x-p1.x)*(p2.x-p1.x)*1.0 );
}
bool cmp(node p1,node p2)
{
    double tmp=CJ(p[1],p1,p[1],p2);
    if(tmp>0) return 1;
    if(tmp==0 && dis(p[0],p1)<dis(p[0],p2)) return 1;
    return 0;
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i)
    {
        scanf("%lf%lf",&p[i].x,&p[i].y);
        if(i!=1&&p[i].y<p[1].y)
        {
            mid=p[1].y;p[1].y=p[i].y;p[i].y=mid;
            mid=p[1].x;p[1].x=p[i].x;p[i].x=mid;
        }
    }  

    sort(p+2,p+1+n,cmp);
    s[1]=p[1];
    int tot=1;
    for(int i=2;i<=n;i++)
    {
        while(tot>1&&CJ(s[tot-1],s[tot],s[tot],p[i])<=0) tot--;
        tot++;
        s[tot]=p[i];
    }
    s[tot+1]=p[1];
    for(int i=1;i<=tot;i++) ans+=dis(s[i],s[i+1]);
    printf("%.2lf\n",ans);
    return 0;
}

 

3.递推，矩阵初步与数列

①几个有趣的特殊数列

②ologn求通项的几（两）种方法（noipt2t3）{

1.特征根

这个东西没有任何代码。。。就是求数列通项。

通过特征方程解出跟

然后带a1，a2，a3……an进去

可以看看这个

https://wenku.baidu.com/view/6e270e87284ac850ac024203.html

2.矩阵快速幂

这个十分好理解（在矩阵乘法理解的基础上）我们可以认为数列是一个行向量

而一个n阶递推数列对应一个列向量，所以因此我们就需要找到一个由前一个列向量递推到下一个的矩阵。

这个矩阵可以记一个结论

它是 对于n阶矩阵 ai为系数

n*n大小

[a1,a2,a3,a4,……,an]

[10000000000……00]

[010000000……00]

[0010000000……00]

[00010000000……00]

[000010000000……00]

.

.

[0………………1]

然后 矩阵快速幂！！！

就是矩阵乘法代替那个快速幂的乘就行

代码！！！

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int n,k;
struct mix{
    int a[105][105];
};
mix mx (mix a1,mix a2,int n)
    {    
        mix a3;int ans=0;
        memset(a3.a,0,sizeof(a3.a));
        for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            ans=0;
        for(int k=1;k<=n;k++)
        {
            ans+=a1.a[i][k]*a2.a[k][j];
        }
        a3.a[i][j]=ans; 
        } 
        return a3;
    }
mix ksm(mix a,int x)
{
    mix ans;
    memset(ans.a,0,sizeof(ans.a));
    for(int i=1;i<=n;i++)
    ans.a[i][i]=1;
    for(;x;x>>=1)
    {
        if(x&1)
        mx(ans,a,n);
        mx(a,a,n);
    }
    return ans;
} 
int main()
{
    mix m1;
    cin>>n>>k;
    cout<<endl<<n<<endl<<k;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    cin>>m1.a[i][j];
        
    mix m=ksm(m1,k);
    for(int i=1;i<=n;i++)
    {
        cout<<endl;
    for(int j=1;j<=n;j++)
        {
            cout<<m.a[i][j]<<" ";
        }
    }
    cout<<endl<<n<<endl<<n;
    return 0;
}
 

 

}

③关于高斯消元基础（noip不会考于t1t2）{

　　这个模板是用来解决n阶定方程的

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define maxn 100
using namespace std;
int n,m,k,l,a,b,c;double mp[maxn][maxn];
int main(){
    cin >> n;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= n + 1; j ++)
            cin >> mp[i][j];   
    for(int j = 1; j <= n; j ++){
        int rgt = 0;
        for(int i = j; i <= n; i ++)
            if(mp[i][j]){rgt = i; break;}
        if(!rgt)continue;
        if(rgt ^ j)swap(mp[rgt],mp[j]);
        
        for(int i = j + 1; i <= n; i ++){
            double div = mp[i][j] / mp[j][j];
            for(int k = 1; k <= n + 1; k ++)mp[i][k] -= div*mp[j][k];
        }
    }
    for(int j = n; j >= 1; j --){
        if(mp[j][j] == 0){cout<<"No Solution"; return 0;}
        mp[j][n+1] =  mp[j][n+1] / mp[j][j];
        for(int i = j-1; i >= 1; i --)mp[i][n+1] -= mp[j][n+1] * mp[i][j];
    }
    for(int i = 1; i <= n; i ++)printf("%.2lf\n" ,mp[i][n+1]);
    return 0;
}

高斯消元还可以解决一些异或，异或这个东西跟加法很相似。

因为若 a+(1<<k)&&（a>>k)&1==0 这个时候更加一样，否则就是减。

我们发现高斯消元是on^3的，那么如果让跑1000之内的怎么办呢。

我们就需要一个玄学的东西叫做线型基！

这个东西是一个纯粹的省选算法，noip向了解即可。

}

④基本数列公式

{

1.等比数列求和

2.等差数列求和

3.等差数列性质

} 

题目

1.P3938 斐波那契

2.P1306 斐波那契公约数

3.P1962 斐波那契数列

4.P1939 【模板】矩阵加速（数列）

5.T37388 P哥破解密码

　4.函数（积性函数初步）

①三分法{

用于求单峰函数的极值

我们发现如果取两个点（三分之一位置）mid1 mid2

会有三种情况（还有一种是相等，那时候任意都行）

mid1>mid2那么峰值不可能在mid2-r;

mid1<mid2峰值不可能在 l-mid1;

那么我们就会发现递推即可缩小lr

锁定峰值

洛谷搜索三分法有模板

// luogu-judger-enable-o2
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<iostream>
#include<queue>
#define maxn 1000
using namespace std;
double n,m,a,b,mid1,mid2,k[maxn];
double f(double x){
    double ans;
    ans=k[0];
    for(int i=1;i<=n;i++){
        ans+=pow(x,i)*k[i];    
    }
    return ans;
}
double sanfen(double l,double r){
    if(r-l<0.000001)return l;
    double mid1=(r-l)/3+l;
    double mid2=r-(r-l)/3;
    //cout<<f(mid1)<<" "<<f(mid2)<<endl;
    if(f(mid1)>f(mid2))r=mid2;
    else l=mid1;
    return sanfen(l,r);
} 
int main(){
    cin>>n>>a>>b;
    
    for(int i=n;i>=0;i--){
        cin>>k[i];
    }//cout<<f(a)<<" "<<f(b)<<endl; 
    printf("%.5lf",sanfen(a,b));
    return 0;
}

这个东西还可以处理凸壳（见计算几何）

}

② 欧拉函数

我在前面写了筛法，自己回去找吧

有用的性质（莫比乌斯反演证明出来的）(Σ（d|n）φ（d）)=n

中间的竖杠，整除的意思。

③莫比乌斯反演初步——这个noip如果考了 ccf就是疯了，真的！！！！！

做题可以看一个叫popoqqq的人的博客最底下。

5.概率论

考过 不难 没啥好总结的 主要是推式子 那就结束吧

省选数学有哪些内容呢？ 

哎，加油吧！

 

 

 

 

一维数学
exgcd，crt，excrt，gcd，bsgs，exbsgs，快速幂，龟速乘，哈希，MillerRabin，Ruben rho，线性筛积性函数，素数线性筛，欧拉公式，费马小定理，乘法逆元，欧拉函数优化快速幂，拉格朗日查值，莫比乌斯反演，fft/ntt，杜教筛，高斯函数化简，牛顿迭代，泰勒展开。
计算几何
凸包，半平面交，旋转卡壳，三分法，导数，定积分分析时间复杂度
组合数学(二维数学)
卢卡斯定理，拓展卢卡斯，matrixtree，高斯消元，异或方程，线性基，行列式求值，矩阵乘法，矩乘快速幂，递推数列特征根