NOIP常用算法笔记

数论部分

常用技巧

快速幂

快速幂的基础：
$$p^q\mathrm{mod}r=\{\begin{array}{ll}(p^2{)}^{\lfloor q÷2\rfloor }\mathrm{mod}r& q\mathrm{mod}2=0\\ p((p^2{)}^{\lfloor q÷2\rfloor })\mathrm{mod}r& q\mathrm{mod}2=1\\ 1& q=1\text{ or }(p=0\text{ and }q\ne 1)\end{array}$$

然后，我们可以一级一级的分下去，分到1为止，时间复杂度为$\Theta (\log q)$，可以接受。

int fp(int p,int q,int r){
    if(q==0||p==1) return 1;
    int g=fp(p*p,q>>1,r)%r;
    if(q&1) g=g*p%r;
    return g;
}

最大公约数

使用欧里几得的定理：
gcd ⁡ { a , b } = { b a   m o d   b = 0 gcd ⁡ { b , a   m o d   b } Otherwise \gcd\{a,b\}=\begin{cases}b&a\bmod b=0\\\gcd\{b,a\bmod b\}&\text{Otherwise}\end{cases} gcd{a,b}={bgcd{b,amodb}​amodb=0Otherwise​

int gcd(int a,int b){
    return a%b==0?b:gcd(b,a%b);
}

当然，如果你想背代码的话，可以将下面的记下来：

int gcd(int a,int b){
    if(b==0) return a;
    if(a==0) return b;
    int acnt,bcnt;
    for(acnt=0;(a&1)==0;acnt++) a>>=1;
    for(bcnt=0;(b&1)==0;bcnt++) b>>=1;
    if(bcnt<acnt) acnt=bcnt;
    while(1){
        if(a<b) swap(a,b);
        if((a-=b)==0) return y<<acnt;
        while((x&1)==0) x>>=1;
    }
}

最小公倍数

因为，$ab=\gcd (a,b)\cdot \text{lcm}(a,b)$，
所以，$\text{lcm}(a,b)=\frac{ab}{\gcd (a,b)}$。

扩展欧几里得算法

已知$a,b$，求一组$p,q$使得$ap+bq=\gcd (a,b)$。

$\because \gcd (a,b)=\gcd (b,a\mathrm{mod}b)$

$\therefore ap+bq=\gcd (b,a\mathrm{mod}b)$

$\begin{array}{rl}\therefore ap+bq& =b{p}^{\prime }+(a\mathrm{mod}b)q^{\prime }\\ & =b{p}^{\prime }+(a-\frac{b}{a}\cdot b)q^{\prime }\\ & =b{p}^{\prime }+a{q}^{\prime }-b{q}^{\prime }\cdot \frac{b}{a}\\ & =a{q}^{\prime }+b(p^{\prime }-\frac{b}{a}\cdot q^{\prime })\end{array}$

即$p=q^{\prime },q=p^{\prime }-\frac{a}{b}\cdot q^{\prime }$

而$\gcd (a,b)$一定会达到$a=1,b=0$时的情况，此时$p=1,q=0$，所以答案是前面的向上递归即可。

放代码：

int exgcd(int a,int b,int &p,int &q){
    if(b==0){
        p=1,q=0;
        return 1;
    }
    int g=exgcd(b,a%b,p,q);
    int t=p;
    p=q,q=t-a/b*q;
    return g;
}

素数

相关定理

1. 唯一分解定理
   $$a=p_1\times p_2\times p_3\times ...\times p_d(a\ge 2)$$
2. 威尔逊定理
   $$(p-1)!\equiv -1(\mathrm{mod}p)$$
3. 费马小定理
   $$x^n\mathrm{mod}x=n(x\ne 2)$$

素数筛法

埃拉托色尼筛法

bool isprime[maxn]={};
memset(isprime,true,sizeof(isprime));
isprime[0]=isprime[1]=false;
for(int i=2;i<maxn;i++){
    if(isprime[i]){
        for(int j=i*2;j<=maxn;j+=i) isprime[j]=false;
    }
}
for(int i=2;i<100;i++){
    if(isprime[i]) cout<<i<<" ";
}

如果要判定的话，只需要判断isprime[i]为true即可。

素数判定

素数性质判定

bool isprime(int x){
    if(x==0||x==1) return false;
    for(int i=2;i<x;i++){
        if(x%i==0) return false;
    }
    return true;
}

图论部分

图的定义

如果使用简单的定义，就是用点将边连起来。若是使用恐怖的定义，那么图的定义$\text{graph}=(V,E)$，其中$V$为所有的点，$E$为所有的边。（请记住，下面会用）

单源最短路

单源最短路是图论中最基础的算法，它可以求出一个点到其他的点的所有的最短路径的长度。

Dijkstra算法

Dijkstra算法的保证基础是这样的：对于一个已经被寻找到的点，没有比它更小的点去走。

首先，列一下Dijkstra算法的流程。

如果有一个图$G(V,E)$且$V$的大小为$n$而$E$的大小为$m$，$s$到其他点的最短路长用$\text{dis}$记。

初始化$\text{dis}$数组（点$s$到所有点的最短路径，除了${\text{dis}}_{x\in V\text{ and }x\ne s}=\infty ,{\text{dis}}_s=\infty$）并标记$s$。
循环$n$遍

找到$\text{dis}$数组中未标记过且值最小的点的标号记为$p$
标记$p$
更新与$p$点链接的所有的点的$\text{dis}$值

下面，我们来放一下代码。

#include <iostream>
#include <vector>
#include <map>
#define inf 2147483647
using namespace std;
int main(){
    int n,m,s,dis[10001]={};
    vector<pair<int,int> > ed[10001]={};
    bool book[10001]={};
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++){
        int from,to,dis;
        cin>>from>>to>>dis;
        ed[from].push_back(make_pair(to,dis));
    }
    for(int i=1;i<=n;i++) if(i!=s) dis[i]=inf;
    for(auto it:ed[s]) dis[it.first]=it.second;
    book[s]=true;
    for(int i=1;i<=n+1;i++){
        int minn=inf,p=-1;
        for(int j=1;j<=n;j++) if(!book[j]&&dis[j]<minn) minn=dis[j],p=j;
        book[p]=true;
        for(auto jt:ed[p]) if(jt.first!=s) dis[jt.first]=min(dis[jt.first],dis[p]+jt.second);
    }
    for(int i=1;i<=n;i++) cout<<dis[i]<<" ";
    return 0;
}

以上就是Dijkstra的代码。

上述算法的时间复杂度为$\Theta (n^2)$，所以我们要对其进行优化。算法中最耗时间的是找到$p$的那一步，可以使用优先队列进行保存并每次都可以直接取出最小的点。

下面是代码。

#include <iostream>
#include <vector>
#include <queue>
#include <map>
#define inf 2147483647
using namespace std;
struct heapitem{
    int d,u;
    bool operator<(const heapitem oth)const{
        return d>oth.d;
    }
    heapitem(int d,int u):d(d),u(u){}
};
int main(){
    int n,m,s,dis[10001]={};
    vector<pair<int,int> > ed[10001]={};
    bool book[10001]={};
    cin>>n>>m>>s;
    for(int i=1;i<=m;i++){
        int from,to,dis;
        cin>>from>>to>>dis;
        ed[from].push_back(make_pair(to,dis));
    }
    for(int i=1;i<=n;i++) if(i!=s) dis[i]=inf;
    priority_queue<heapitem> que;
    que.push(heapitem(0,s));
    while(!que.empty()){
        heapitem now=que.top();
        que.pop();
        int p=now.u;
        if(book[p]) continue;
        book[p]=true;
        for(auto it:ed[p]) if(dis[it.first]>dis[p]+it.second) dis[it.first]=dis[p]+it.second,que.push(heapitem(dis[it.first],it.first));
    }
    for(int i=1;i<=n;i++) cout<<dis[i]<<" ";
    return 0;
}

常用数据结构

树状数组

又称fenwick树，是求前缀和等的一种好方法。

首先，这棵树的形态如下（画的不太好：）

---------------------+
---------+           |
---+     |  ---+     |
+  |  +  |  +  |  +  |
0  1  2  3  4  5  6  7

其中，有加号的地方就代表有一个点在哪里，而上面的减号横线代表的就是它所覆盖的区域。