算法与数据结构模版（AcWing算法基础课笔记，持续更新中）

AcWing算法基础课笔记

第一章 基础算法

包括排序、二分、高精度、前缀和与差分、双指针算法、位运算、离散化、区间合并

1. 排序

快速排序：

思路：基于分治思想

1. 确定分界点（取左边界，去中间点，随机取）
2. 调整区间，分x两部分分别是[l, j]、[j+1, r]
3. 递归左右

void quick_sort(vector<int>&q, int l, int r)
{
    if (l >= r) return;  //注意这里是>=
    int i = l - 1, j = r + 1, x = q[l + r >> 1];
    while (i < j)
    {
        while (q[++i] < x);  //注意这里无论结果如何i都会+1，故初始化时i=l-1，且才能跳出循环
        while (q[--j] > x);
        if (i < j) swap(q[i], q[j]);
    }
    quick_sort(q, l, j), quick_sort(q, j + 1, r);
}

归并排序：

思路：基于分治思想

1. 确定分界点: 中间点 mid=l+r>>1
2. 递归分界点左右
3. 归并

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;  //return边界
    int mid = l + r >> 1;
    merge_sort(q, l, mid);  //排序左半
    merge_sort(q, mid + 1, r);  //排序右半

    int k = 0, i = l, j = mid + 1;  //将i，j分别指向两数组第一个元素
    while (i <= mid && j <= r)  //若两数组都没结束，选小的进
        if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
        else tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];  //一数组结束，另外一数组剩下元素依次进
    while (j <= r) tmp[k ++ ] = q[j ++ ];

    for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}

2. 二分

本质：可以划分为满足某种性质与不满足某种性质的两个区间，用二分法可以找到两区间边界的左右两个点。

整数二分

int bsearch_1(int l, int r)  //寻找右边界
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;  //右边界需+1
        if (q[mid]>k) r = mid-1;  //mid不满足<=，直接将右边界置mid左边
        else l = mid;  //左边界一点点贴近右边界
    }
    return l;
}
int bsearch_2(int l, int r)  //寻找左边界，同理
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (q[mid]<k) l = mid+1;
        else r = mid;
    }
    return l;
}

浮点数二分

void bsearch_3(double l, double r)  //所有可能的范围如[-10000,10000]
{
    const double eps = 1e-8;  //要求精度多两位
    while (abs(r - l) > eps)
    {
        double mid = (l + r) / 2;
        if (n-pow(mid,3)<eps) r = mid;  //两者不断接近
        else l = mid;
    }
    printf("%lf",r);
}

3. 高精度

高精度加法

void add(vector<int>&a,vector<int>&b){
    if(a.size()<b.size()) return add(b,a);  //确保a>b，由于都是正整数，所以可以这么操作
    int c=0;
    for(int i=0;i<a.size();i++){
        a[i]+=c;  //a+b+c（进位符）
        if(i<b.size()) a[i]+=b[i];  //注意a还有，b没了
        c=a[i]/10;
        a[i]%=10;
    }
    if(c) a.push_back(1);  //注意最后一位进位
    for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}

高精度减法

void sub(vector<int>&a,vector<int>&b){
    int c=0;
    for(int i=0;i<a.size();i++){  //同理变成减
        a[i]-=c;
        if(i<b.size()) a[i]-=b[i];
        if(a[i]<0) c=1;
        else c=0;
        a[i]=(a[i]+10)%10;
    }
    while(a.size()!=1&&a[a.size()-1]==0) a.pop_back();  //注意是while不是if，如果高位为0要一直减
    for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}

高精度乘法

乘法与加法类似，但由长整数乘以短整数，故不是一位乘一位，是以长整数的一位乘整个短整数。

void mult(vector<int>&a,int b){
    int c=0;
    for(int i=0;i<a.size();i++){
        a[i]=b*a[i];  //同理，注意先乘后加
        a[i]+=c;
        c=a[i]/10;
        a[i]%=10;
    }
    while(c!=0){  //若用新数组保存值每次push_back，for循环条件可以为a.size()||c，减少这个while语句
        a.push_back(c%10);
        c/=10;
    }
    while(a.size()!=1&&a.back()==0) a.pop_back();
    for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}

高精度除法

模拟除法，从高位开始，（余数*10+高位）除以除数得商的高位，%除数得新的余数，循环。

void div(vector<int>&a,int b){
    int t=0;
    vector<int> c;
    for(int i=0;i<a.size();i++){
        t=t*10+a[i];
        if(c.size()!=0||t/b!=0) c.push_back(t/b);  //用if去除高位的0，可以用reverse函数倒置去0同理
        t%=b;
    }
    if(c.size()==0) c.push_back(0);
    for(int i=0;i<c.size();i++) printf("%d",c[i]);
}

4. 前缀和与差分

前缀和

前缀和定义：S[i] = a[1] + a[2] + … a[I]
求区间（注意后者边界l-1）：a[l] + … + a[r] = S[r] - S[l - 1]
补充：S0=0，消除[1，r]时的特殊处理

矩阵前缀和

同理，注意矩阵从a11开始，注意容斥问题
以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：
S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]

一维差分

题目要求在某区间加一个值val
构造一个差分数组b1, b2, b3 … bn
它的前缀和数组a1, a2, a3 … an（该数组为最后答案要求数组）

原理：若在a数组的区间[l, r]上依次加val，时间复杂度on；若在b数组上bl + val、br+1 - val，最后求它的前缀和数组a得到相同结果，时间复杂度o1

思路：虽然题目初始化的数组有值，但我们仍初始化一个全0的差分数组b，在[l, l]同一位置上依次插入初始值，然后按题目要求在[l,r]上插入即可；
注意同样a0、b0都为0，插入代码：

void insert(int l,int r,int val){  //由于最后结果是前缀和数组，在差分数组l上加val，使得[l, + ∞)上都加val，在r+1上减val得到仅在区间[l,r]上加val
    q[l]+=val;
    q[r+1]-=val;
}

二维差分

同理，插入代码如下：

void insert(int x1,int y1,int x2,int y2,int v){  //注意容斥问题、矩阵从a11开始、矩阵初始化大小行列都得+2
    q[x1][y1]+=v;
    q[x1][y2+1]-=v;
    q[x2+1][y1]-=v;
    q[x2+1][y2+1]+=v;
}

5. 双指针算法

问题分类：

1. 对于一个序列，用两个指针维护一段区间；
2. 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作；

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;  //寻找i，j的单调关系
    // 具体问题的逻辑
}

6. 位运算

n 的二进制表示中，第k位是几

1. 先把第k位移到最后一位：n >> k
2. 看个位是几：x & 1
   即：n >> k & 1

求二进制中1的个数

lowbit(x)：返回x的最后一个1，即101000得1000；
原理：x&-x = x&(~x+1)

int lowbit(int x){
	return x & -x;
}

7. 离散化

场景：目标数据稀疏的分散在大数组空间中，大部分元素为0
题目：给下标范围[-1e-9,1e-9]的数组存入几个数，求某段范围所有值的和
思路（将大下标范围的数组映射到一个小的数组中，然后具体按题目要求操作）：

1. 首先取操作涉及的下标，即将要存数字的下标与求和范围两端的下标，存入小数组q中
2. 对数组q排序，且去重，c++代码如下
3. 重新创建一个大小与q相同的数组s，从数组q中找到对应大数组要存入数据的位置映射，在s相同位置存入数据（q中找映射可以用二分法）
4. 找大数组求和范围两端点在q中的映射位置，在数组s对应映射位置求和即可，可用前缀和；

sort(q.begin(), q.end()); // 对数组q排序
q.erase(unique(q.begin(), q.end()), q.end());   // 去掉重复元素

补充：题目比较综合，贴一个代码链接：
https://www.acwing.com/activity/content/code/content/3230155/

8. 区间合并

场景：离散的区间，合并相交的区间
步骤：

1. 按区间的左端点排序；
2. 从左到右扫描，维护一个当前区间（随着遍历，若相交则区间变长）
3. 每次遍历的区间和当前区间有三种情况分类讨论：
   （1）右端点小于当前区间右端点，当前区间不变；
   （2）右端点大于当前区间右端点，当前区间变长；
   （3）左端点大于当前区间右端点，将该区间置为当前区间；

第二章 数据结构

1. 单链表

数组模拟单链表

int v[N],l[N],idx; //初始化，分别为值、下一结点坐标、下一结点下标

void init(){
    l[0]=-1;
    idx=1;
}
void insert(int k,int x){ //去head，直接idx=0存头指针，使k无需-1，且消除头结点的特殊操作
    v[idx]=x;
    l[idx]=l[k];
    l[k]=idx++;
}
void delete_v(int k){
    l[k]=l[l[k]];
}

2. 双向链表

数组模拟双向链表

int v[N],l[N],r[N],idx; //同理

void init(){
    l[0]=-1,r[0]=1,l[1]=0,r[1]=-1;  //用最开始两个结点做头尾指针
    idx=2;
}
void insertL(int k,int x){  //注意这里的三个函数，由于占用了数组前两个元素，题目给的k值需要+1
    v[idx]=x;
    l[idx]=l[k];
    r[idx]=k;
    r[l[k]]=idx;
    l[k]=idx++;
}
void insertR(int k,int x){
    v[idx]=x;
    r[idx]=r[k];
    l[idx]=k;
    l[r[k]]=idx;
    r[k]=idx++;
    
}
void delete_v(int k){
    r[l[k]]=r[k];
    l[r[k]]=l[k];
}

3. 栈

数组模拟过于简单，补充模拟栈处理中缀表达式：
main函数思路：

1. 如果栈顶是+，即将入栈的是+，栈顶优先级高，需要先计算，再入栈；
2. 如果栈顶是+，即将入栈的是*，栈顶优先级低，直接入栈；
3. 如果栈顶是*，即将入栈的是+，栈顶优先级高，需要先计算，再入栈；
4. 如果栈顶是*，即将入栈的是*，栈顶优先级高，需要先计算，再入栈；

#include 
using namespace std;
const int N=100010;
int n[N],t_n=0,t_c=0; //初始化数值栈与符号栈
char c[N];
string str;
void pop_c(){ //取一个符号，两个数值，计算后压入数值栈
    char s=c[--t_c];
    int a=n[--t_n];
    int b=n[--t_n];
    if(s=='+') n[t_n++]=a+b;
    else if(s=='-') n[t_n++]=b-a;
    else if(s=='*') n[t_n++]=a*b;
    else n[t_n++]=b/a;
}
int push_n(int i){ //将数值压入数值栈
    int r=0;
    while(str[i]<='9'&&str[i]>='0'){
        r=r*10+str[i]-'0';
        i++;
    }
    n[t_n++]=r;
    return i-1;
}
int main(){
    cin>>str;
    for(int i=0;i<str.size();i++){
        if(str[i]<='9'&&str[i]>='0')
            i=push_n(i);
        else if(t_c==0||str[i]=='(')c[t_c++]=str[i];
        else if(str[i]=='+'||str[i]=='-'){
            while(t_c!=0&&c[t_c-1]!='('){
                pop_c();
            }
            c[t_c++]=str[i];
        }else if(str[i]=='*'||str[i]=='/'){
            while(c[t_c-1]=='*'||c[t_c-1]=='/'){
                pop_c();
            }
            c[t_c++]=str[i];
        }else if(str[i]==')'){
            while(c[t_c-1]!='(') pop_c();
            t_c--; //放到while里报错了好久，while循环外去除（
        }
    }
    while(t_c) pop_c();
    printf("%d",n[0]);
}

4. 队列

循环队列注意点：队满与队空条件需要有区别，即需要一个额外的元素空间判断队空与队满

void push_q(int x){
    if((tail+N+1)%N!=head){  //判断队满
        q[tail]=x;
        tail=(N+tail+1)%N;  //队尾插入一个数据注意指针移动需要%N，对头类似：head=(N+head+1)%N;
    }
}
bool empty(){  //判断是否为空
    return head==tail;
}
void pop_q(){  //对头删去一个元素
    if(!empty())
        head=(N+head+1)%N;
}
void query(){  //查询对头元素
    if(!empty())
        printf("%d\n",q[head]);
}

5. 单调栈

应用场景：求某个数左边第一个小于他的数；
思路：
在每次暴力从for循环的当前值，向左遍历找第一个小于数的O(n2)情况下进行优化；
在向左遍历过程中删去无用的数（左边小于，但值大于），利用栈形成单调增大的序列，所求数即为栈顶；

for(int i=0;i<n;i++){
    scanf("%d",&v);
    while(top&&s[top-1]>=v) top--; //去除比当前数大但在左边的数
    if(!top) printf("-1 ");
    else printf("%d ",s[top-1]); //输出栈顶元素，即第一个小于当前数的数
    s[top++]=v; //当前数压入栈中
}

6. 单调队列

应用场景：滑动窗口中最小值，也可优化背包问题；
思路：同理通过删去无用的数进行优化；
（求滑动窗口中最小值）队列头保留最小的数，遍历数组，若队尾数大于遍历的数则不断删去队尾（同理无用的数），使得队列单调增，在遍历过程中，不断更新队头使得不超过滑动窗口。

for(int i=0;i<n;i++){
   if(l<r&&i-q[l]>len-1) l++; //移动对头使不超过滑动窗口，为了实现，q数组存下标
   while(l<r&&v[q[r-1]]>=v[i]) r--; //弹出队尾无用数，因为会在队尾弹出不满足先进先出原则，事实上也不能叫单调队列
   q[r++]=i; //每次都入队一个
   if(i>=len-1) printf("%d ",v[q[l]]);
}

7. KMP算法

应用场景：字符串匹配，使时间复杂度为O(n)
思路：利用next数组减少模式串回退的长度。

cin >> n >> p+1 >> m >> s+1;// char数组s是长文本，p是模式串，且从数组下标1开始存储
for(int i=2,j=0;i<=n;i++){  //求next数组
    while(j&&p[i]!=p[j+1]) j=ne[j];
    if(p[i]==p[j+1]) j++;
    ne[i]=j;
}
for(int i=1,j=0;i<=m;i++){  //匹配
    while(j&&s[i]!=p[j+1]) j=ne[j];
    if(s[i]==p[j+1]) j++;
    if(j==n){
        j=ne[j];
        //匹配成功
    }
}

8. Trie

应用：高效地存储和查找字符串集合的数据结构、前缀树相关应用

int son[N][26], cnt[N], idx;
// 0号点既是根节点，又是空节点
// son[][]存储树中每个节点的子节点
// cnt[]存储以每个节点结尾的单词数量
// idx标记每个节点位置，每插入一个结点+1

// 插入一个字符串
void insert(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) son[p][u] = ++ idx;
        p = son[p][u];
    }
    cnt[p] ++ ;
}

// 查询字符串出现的次数
int query(char *str)
{
    int p = 0;
    for (int i = 0; str[i]; i ++ )
    {
        int u = str[i] - 'a';
        if (!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

9. 并查集

很容易考察：代码短，思路精巧
原理：每个集合用一棵树表示。树根的编号就是整个集合的编号。每个节点存储它的父节点，p[x]表示x的父节点。
血的教训!!!
注意很多题目需要在合并时去最小值，若f数组存父亲值
f[y]=min(f[x],f[y]),f[x]=min(f[x],f[y]);
每次执行find操作，确实会让每个节点直接存根节点的值，之后查找的时间复杂度接近O(1)，但仅仅是接近，不一定全是1次找到，即之后查找要用find函数而不是直接f[]找。

//经典find函数
int find(int x)
{
    if (p[x] != x) p[x] = find(p[x]);
	return p[x];
}
//维护到祖宗节点距离的并查集（题目：食物链）
int find(int x)
{
    if (p[x] != x)
    {
        int u = find(p[x]); //直接一路递归到根节点
        d[x] += d[p[x]]; //从根节点回来，加上一路的距离
        p[x] = u;
    }
    return p[x]; //由于d[x]直接保存了到根节点的总长度，故查询完后需要将x直接连在根节点下（直接连在根节点，即路径压缩）
}

10. 堆

1. 建堆：for(int i=size/2;i>0;i–) down(i); //注意从heap[1]开始存
2. 插入一个数：heap[++size] = x; up(size);
3. 删除最小值：heap[1] = heap[size–]; down(1);
4. 删除任意一个元素：heap[k] = heap[size–]; down(k); up(k);
5. 修改任意一个元素：heap[k]=x; down(k); up(k);
   //注意一个个插入，仅保证堆顶为最小值，其他元素没有严格按照堆的标准，故down和up操作不是if…else的关系；

void down(int u)
{
    int t = u;
    if (u * 2 <= size && h[u * 2] < h[t]) t = u * 2;
    if (u * 2 + 1 <= size && h[u * 2 + 1] < h[t]) t = u * 2 + 1; //同样操作，先根左，后根右，注意第二次用的是h[t];
    if (u != t)
    {
        swap(u, t);
        down(t);
    }
}

void up(int u)
{
    while (u / 2 && h[u] < h[u / 2])
    {
        swap(u, u / 2);
        u >>= 1;
    }
}

11. 哈希

开放寻址法

N一般取数据范围的2-3倍，大概率无冲突

int h[N];
    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    int find(int x)
    {
        int t = (x % N + N) % N;
        while (h[t] != INT_MAX && h[t] != x) //INT_MAX在头文件limits.h中
        {
            t ++ ;
            if (t == N) t = 0;
        }
        return t;
    }

拉链法

N取大于空间的第一个质数

int h[N], e[N], ne[N], idx; //类似图论中的临界表存储
// 向哈希表中插入一个数
void insert(int x)
{
    int k = (x % N + N) % N;
    e[idx] = x;
    ne[idx] = h[k];
    h[k] = idx ++ ;
}

// 在哈希表中查询某个数是否存在
bool find(int x)
{
    int k = (x % N + N) % N;
    for (int i = h[k]; i != -1; i = ne[i])
        if (e[i] == x)
            return true;

    return false;
}

字符串哈希

将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i]; //存前缀哈希值
    p[i] = p[i - 1] * P; //存P的x次方
}

// 计算子串 str[l ~ r] 的哈希值
long long get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

12. STL （仅记录我不知道的）

vector

支持比较运算，按字典序
front() / back()
push_back() / pop_back()

string

c_str() 返回字符串所在字符数组的起始地址

queue 队列

front() 返回队头元素
back() 返回队尾元素

priority_queue 优先队列，默认是大根堆

定义成小根堆的方式：priority_queue q;

deque 双端队列

front()/back()
push_back()/pop_back()
push_front()/pop_front()
begin()/end()
[]

set, map, multiset, multimap 基于平衡二叉树（红黑树），动态维护有序序列

++, – 返回前驱和后继，时间复杂度 O(logn)

set/multiset

insert() 插入一个数
find() 查找一个数
count() 返回某一个数的个数
erase()
(1) 输入是一个数x，删除所有x O(k + logn)
(2) 输入一个迭代器，删除这个迭代器
lower_bound()/upper_bound()
lower_bound(x) 返回大于等于x的最小的数的迭代器
upper_bound(x) 返回大于x的最小的数的迭代器

map/multimap

insert() 插入的数是一个pair
erase() 输入的参数是pair或者迭代器
find()
[] 注意multimap不支持此操作。 时间复杂度是 O(logn)
lower_bound()/upper_bound()

unordered_set, unordered_map, unordered_multiset, unordered_multimap, 哈希表

和上面类似，增删改查的时间复杂度是 O(1)
不支持 lower_bound()/upper_bound()， 迭代器的++，–

bitset 圧位，仅占1/8

bitset<10000> s;
~, &, |, ^
>>, <<
==, !=
[]
count() 返回有多少个1
any() 判断是否至少有一个1
none() 判断是否全为0
set() 把所有位置成1
set(k, v) 将第k位变成v
reset() 把所有位变成0
flip() 等价于~
flip(k) 把第k位取反

第三章 搜索与图论

1. DFS

思路：本质上用dfs去枚举，在此基础上剪枝，以皇后问题为例：

void dfs(int l,int x,int y){
    if(y==n){ //让x，y坐标走下去
        y=0;
        x++;
    }
    if(x==n){ //递归边界，结束跳出递归
        if(l==n){
            for(int i=0;i<n;i++) puts(c[i]);
            printf("\n");
        }
        return;
    }
    if(!col[y]&&!row[x]&&!m[x-y+n]&&!p[x+y]){ //用条件剪枝
        col[y]=row[x]=m[x-y+n]=p[x+y]=1;
        c[x][y]='Q';
        dfs(l+1,x,y+1);
        col[y]=row[x]=m[x-y+n]=p[x+y]=0; //注意恢复现场，重要！！
        c[x][y]='.';
    }
    dfs(l,x,y+1);
}

2. BFS

应用场景：求最短路径（要求每步权重相等），模版如下：

st[1] = true; // 表示1号点已经被遍历过
q.push(1);

while (q.size())
{
    int t = q.front();
    q.pop();

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])
        {
            st[j] = true; // 表示点j已经被遍历过
            q.push(j);
        }
    }
}

3. 树与图的存储

注意初始化与有重边取小问题，如果有负权边判定条件由=INF为>INF/2。

邻接矩阵

g[a][b]存储边a->b

临界表

// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;
// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 初始化
idx = 0;
memset(h, -1, sizeof h); //在头文件cstring中

最短路径问题导图

4. Dijkstra

朴素Dijkstra（适合稠密图，无负权值）

思路：

1. 初始化（初始化dist，邻接矩阵）
2. 循环n-1次，每次找最短dist[t]，用t更新其它点的距离

//初始化
memset(g,0x3f,sizeof g);
memset(dist,0x3f,sizeof dist);
g[a][b]=min(c,g[a][b]); //如果有重边，需要选小的
//Dijkstra
bool dijkstra(){
    dist[1]=0;
    for(int i=0;i<n-1;i++){
        int t=-1;
        //找最小的dist
        for(int j=1;j<=n;j++){
            if((t==-1||dist[j]<dist[t])&&!b[j]){
                t=j;
            }
        }
        //更新已访问的点
        b[t]=1;
        //更新该点其它距离
        for(int j=1;j<=n;j++)
            dist[j]=min(g[t][j]+dist[t],dist[j]);
    }
    if(dist[n]==0x3f3f3f3f) return 0;
    else return 1;
}

堆优化的Dijkstra（适合稀疏图，无负权值）

思路：
在朴素Dijkstra算法的基础上

1. 初始化（初始化dist，邻接矩阵）
2. 循环n-1次，每次找最短dist[t]，用t更新其它点的距离
   其中找最短dist[t]需要O(n2)，故利用一个堆把该步骤降为O(n)
   随之用堆更新的时间复杂度上升为O(mlogn)，故适合于稀疏图

int dijkstra(){
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q;
    dist[1]=0;
    q.push({0,1});
    while(q.size()){
        pair<int,int> temp=q.top();
        q.pop();
        if(st[temp.second]) continue; //若已访问直接跳过，若在下方if语句中判断时间差很多
        st[temp.second]=1;
        //更新操作
        for(int i=h[temp.second];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>temp.first+w[i]){
                dist[j]=temp.first+w[i];
                q.push({dist[j],j});
            }
        }
    }
    if(dist[n]!=0x3f3f3f3f) return dist[n];
    else return -1;
}

5. bellman-ford（负权值，若规定k条边最短路径则只能用它，O(nm)）

思路：(很暴力，边的存储仅需要用结构体数组即可)
for n 次
    用back数组备份dist，防止串联（访问前几条边改变数据后影响后面的访问，会破坏k条边的条件）
    for 所有边 a，b，w
         dist[b] = min(dist[b], back[a]+w); //松弛操作
三角不等式：dist[b] <= dist[a]+w
补充：如果执行n次依然更新了路径，说明有n条的最短路径，即有负权边

struct line{ //定义结构体
    int a,b,w;
}lines[N];

void bellman_ford(){
    dist[1]=0;
    for(int i=0;i<k;i++){
        memcpy(back,dist,sizeof dist); //备份防止串联
        for(int j=0;j<m;j++){
            if(dist[lines[j].b]>back[lines[j].a]+lines[j].w){//这里用back
                dist[lines[j].b]=back[lines[j].a]+lines[j].w;
            }
        }
    }
    if(dist[n]>0x3f3f3f3f/2) printf("impossible");
    else printf("%d",dist[n]);
}

6. SPFA（bellman-ford优化，一般O(m),最坏O(nm)）

思路：在bellman-ford的基础上，利用一个队列与广度优先搜索，仅将变小的点加入队列中；
补充：
用一个cnt[]数组维护每个节点的最短路径边数，若边数=n即有负权边。需要考虑图不连通，故需要初始化时把所有点加入队列，且dist都相等即可。

void spfa(){
    q.push(1);
    dist[1]=0;
    st[1]=1;
    while(q.size()){
        int t=q.front();
        q.pop();
        st[t]=0; //SPFA与Dijkstra不同仅在于标记数组用于标记是否重复进去队列而非是否访问过
        for(int i=h[t];i!=-1;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){ //改变后进行判断是否需要加入队列
                    st[j]=1;
                    q.push(j);
                }
            }
        }
    }
    if(dist[n]==0x3f3f3f3f) printf("impossible");
    else printf("%d",dist[n]);
}

7. Floyd

思路：三重循环，用邻接矩阵存储
外层循环每个要加入的点，双层循环两个要加入的节点，如果可加入其中且路径边短则更新即可。

初始化：
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= n; j ++ )
            if (i == j) d[i][j] = 0;
            else d[i][j] = INF;

// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()
{
    for (int k = 1; k <= n; k ++ ) //每次要加入的点
        for (int i = 1; i <= n; i ++ ) //加入点i，j中
            for (int j = 1; j <= n; j ++ )
                d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}

最小生成树与二分图导图

朴素Prim算法用于稠密图，优化版Prim和Kruskal算法侧重于稀疏图，由于堆优化代码长，故一般直接用Kruskal算法。

8. Prim

思路：几乎和dijkstra一样，区别在标记数组记录的是进入生成树的节点，dist数组记录的是各节点到生成树的最短路径；

void prim(){
    dist[1]=0;
    for(int i=0;i<n;i++){
        int t=-1;
        for(int j=1;j<=n;j++){
            if(!st[j]&&(t==-1||dist[t]>dist[j])){
                t=j;
            }
        }
        st[t]=1;
        res+=dist[t];
        for(int j=1;j<=n;j++){
            if(dist[j]>g[t][j]){
                dist[j]=g[t][j];
            }
        }
    }
}

9. Kruskal

思路：用结构体存边，并排序，从最短的边找起，若两点不在一颗树则连接在一起（并查集思想），直到所有点都用最短的边连在一起。

sort(lines,lines+m); //边排序
for(int i=0;i<m;i++){ 
    int a=find(lines[i].a),b=find(lines[i].b);
    if(a!=b){
        h[b]=a; //若不是一棵树操作
        res+=lines[i].c;
        cnt++;
    }
}

10. 染色法判别二分图

二分图：

1. 当且仅当图中不含有奇数环；
2. 图中所有点可以划分为两个区域，所有的边在两个区域之间。
   思路：利用深度优先便利，相邻节点染上不同颜色，若无冲突则为二分图。

bool dfs(int x,int c){
    st[x]=c; //所有深度优先做什么都放在最前面，判断中则会有多余的遍历
    for(int i=h[x];i!=-1;i=ne[i]){
        int j=e[i];
        if(!st[j]){
            if(!dfs(j,3-c)) return false;
        }else if(st[j]==c) return false;
    }
    return true;
}

11. 匈牙利算法

二分图最大匹配问题：分两堆且给出部分边后，尽可能使左右一对一匹配。

//主函数
for(int i=1;i<=n1;i++){
	memset(st,0,sizeof st);
    if(find(i)) res++;
}
//找右半堆
bool find(int x){
    for(int i=h[x];i!=-1;i=ne[i]){
        int j=e[i];
        if(!st[j]){
            st[j]=1; //注意标记置1
            if(!match[j]||find(match[j])){ //如果已经匹配，递归看看拆散一对会不会更好
                match[j]=x;
                return true;
            }
        }
    }
    return false;
}

第四章 数学知识

1. 质数

质数的判定-试除法（稳定 O(sqrt(n)) ）

bool is_prime(int x){
    if(x<2) return false; //记得判断<2都不是质数
    for(int i=2;i<=x/i;i++) //注意有=号
        if(x%i==0)
            return false;
    return true;
}

分解质因数-试除法（ O(logn)-O() ）

void divide(int x){
    for(int i=2;i<=x/i;i++){
        int s=0;
        while(x%i==0){ //for里面加个while计数即可
            x/=i;
            s++;
        }
        if(s!=0) printf("%d %d\n",i,s);
    }
    if(x!=1) printf("%d %d\n",x,1);
}

埃氏筛法 O(nloglogn)

void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!p[i]){ //若是素数，将它所有倍数的标记置1
            res++;
            for(int j=i;j<=n;j+=i) p[j]=1;
        }
    }
}

线性筛法 O(n)

思路：
不同于埃氏筛法，把质数的所有倍数标记置1，该算法将会有很多重复的置1操作（质数的公倍数多次被置1）
线性筛法将以后素数存入数组，实现仅更新当前素数的部分倍数，实现每个数仅被置一次，从而实现线性的时间复杂度。

void get_primes(int n){
    for(int i=2;i<=n;i++){
        if(!p[i]) prime[res++]=i; //若为素数,加入数组
        for(int j=0;prime[j]<=n/i;j++){ //prime[j]
            p[prime[j]*i]=true;
            if(i%prime[j]==0) break; //如果该数为已有素数的公倍数就break，两个跳出条件缺一不可
        }
    }
}

2. 约数

试除法求一个数的所有约数

约数数量未知，故用vector来存储

void get_dividors(int x){
    vector<int> v;
    for(int i=1;i<=x/i;i++){
        if(x%i==0){
            v.push_back(i);
            if(i!=x/i) v.push_back(x/i); //防止相同的数进入
        }
    }
    sort(v.begin(),v.end());
    for(int i=0;i<v.size();i++)
        printf("%d ",v[i]);
}

约数的个数

N=P1^α1 * P2^α2 * … * Pk^αk
约数个数公式：(α1+1)(α2+1)…(αk+1)

//用unordered_map求约数，约数个数和约数之和一样
void get_dividor(int x){
    for(int i=2;i<=x/i;i++){
        while(x%i==0){
            x/=i;
            m[i]++;
        }
    }
    if(x>1) m[x]++;
}
//按公式相乘取余
for(auto it=m.begin();it!=m.end();it++){
	res=res*(it->second+1)%N;
}

约数之和

N=P1^α1 * P2^α2 * … * Pk^αk
约数之和公式：(P1^0 + P1^1 + P1^α1) … (Pk^0 + Pk^1 + Pk^α1)

//按公式相乘取余
long long get_p(int a,int b){
    long long r=1;
    for(int i=0;i<b;i++){
        r=(r*a+1)%N;
    }
    return r;
}
for(auto it=m.begin();it!=m.end();it++){
	res=res*get_p(it->first,it->second)%N;
}

欧几里得算法（辗转相除法，求最大公约数）

（a, b）的最大公约数=（b, a mod b）的最大公约数

//有点难理解，但一行直接背
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

3. 欧拉函数

4. 快速幂

5. 扩展欧几里得算法

补充

cin、cout与scanf、printf

用cin.tie(0);和ios::sync_with_stdio(false);加快cin、cout输入输出，但不能再使用scanf与printf且依然慢；
原理是让cin、cout与标准数输入输出不同步；