算法模板总结

阿斯卡码

已于 2024-09-04 21:49:59 修改

阅读量1.3k

点赞数 30

分类专栏： codeforces 文章标签：算法排序算法数据结构

于 2024-08-02 21:34:51 首次发布

本文链接：https://blog.csdn.net/qq_52384627/article/details/140880687

版权

codeforces 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

这里写目录标题

快速排序

快速排序思路：
1.确定分界点，一般取mid=a[i+j>>1];
2.调整区间，即左边<=mid,右边>=mid
3.递归两边qs(a,l,j),qs(a,j+1,r);
时间复杂度： NlogN

void QuickSort(int a[],int l,int r)
{
    if(l>=r)return ;
    int i=l-1,j=r+1,mid=a[(i+j)/2];
    while(i<j)
    {
        do i++;while(a[i]<mid);//找到大于等于mid的a[i]
        do j--;while(a[j]>mid);//找到小于等于mid的a[j]
        if(i<j)swap(a[i],a[j]);
    }
    QuickSort(a,l,j),QuickSort(a,j+1,r);
}

快速排序应用：第k个数
寻找第k小(大)的数，以第k小为例，划分区间：[L,J][J+1,R]。leftCount=J - L + 1，若左区间的个数 leftCount>= k ，即第k个数在左侧；否则就在右侧，k变为 k - leftCount。
1.快速排序的思想
2.递归结束条件：if(l>=r)return a[l];
3.左右递归：k<=sl递归左，k>sl递归右
时间复杂度： N

int QuickSort(int a[],int l,int r,int k)
{
    if(l>=r)return a[l];
    int i=l-1,j=r+1,mid=a[(i+j)/2];
    while(i<j)
    {
        do i++;while(a[i]<mid);
        do j--;while(a[j]>mid);
        if(i<j)swap(a[i],a[j]);
    }
    int leftCount = j-l+1;
    if(leftCount>=k) return QuickSort(a,l,j,k);//左区间个数>=k，在左区间
    else return QuickSort(a,j+1,r,k-leftCount);//左区间个数<k，在右区间
}

归并排序

归并排序思路：
1.递归的终止情况
2.递归处理子问题 MergeSort(a,l,mid),MergeSort(a,mid+1,r)
3.合并子问题
时间复杂度： NlogN
注：temp[]数组复制到a[]数组是必须的，回到上一层调用函数时，需要让a[]数组对应的位置有序。

void MergeSort(int a[],int l,int r)
{
    if(l>=r)return ;//递归终止
    
    int mid = (l+r)/2;
    MergeSort(a,l,mid),MergeSort(a,mid+1,r);//递归子问题
    
    //合并子问题
    int i=l,j=mid+1,k=0,temp[N];
    while(i<=mid&&j<=r)
    {
        if(a[i]<=a[j])temp[k++]=a[i++];
        else temp[k++]=a[j++];
    }
    while(i<=mid)temp[k++]=a[i++];
    while(j<=r)temp[k++]=a[j++];
    
    for(i=l,k=0;i<=r;i++,k++)a[i]=temp[k];
}

归并排序应用：逆序对的数量
1.将逆序对分成三类：A两个元素都在左边；B两个元素都在右边；C两个元素一个在左一个在右；
2.这个时候我们注意到一个很重要的性质，左右半边的元素在各自任意调换顺序，是不影响第三步计数的，因此我们可以数完就给它排序。这么做的好处在于，如果序列是有序的，会让第三步计数很容易。
时间复杂度： NlogN

long long MergeSort(int a[],int l,int r)
{
    if(l>=r)return 0;//递归终止返回0
    
    int mid = l+r>>1;
    long long res = MergeSort(a,l,mid)+MergeSort(a,mid+1,r);//都在左+都在右
    
    int i=l,j=mid+1,k=0;
    int temp[N];
    while(i<=mid&&j<=r)
    {
        if(a[i]<=a[j])temp[k++]=a[i++];
        //一个在左、一个在右   前数字>后数字
        else
        {
            temp[k++]=a[j++];
            res = res + mid-i+1;//左部分a[i]已经>a[j]，所以a[i]之后的都是大于a[j]
        }
    }
    while(i<=mid)temp[k++]=a[i++];
    while(j<=r)temp[k++]=a[j++];
    for(i=l,k=0;i<=r;i++,k++)a[i]=temp[k];
    
    return res;
}

二分

整数二分

前提：只要数组能够满足某一条件而被分成两边就可以二分。
注意：男左（+1）女右（+0）
（1）mid = l + r >> 1，寻找的是第一个大于等于x的数【右区间最左边的点】
（2）mid = l + r + 1 >> 1，寻找的是第一个小于等于x的数【左区间最右边的点】
时间复杂度：logN

bool check(int x) {/* ... */} // 检查x是否满足某种性质

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：【右区间最左边的点】
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (checkRight(mid)) r = mid;//checkRight(mid)右边性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：【左区间最右边的点】
int bsearch_2(int l, int r)
{
    while (l < r)
    {
        int mid = l + r + 1 >> 1;
        if (checkLeft(mid)) l = mid;//checkLeft(mid)左边性质
        else r = mid - 1;
    }
    return l;
}

浮点数二分
注意事项：一定要是double类型，不能是float类型，否则会超时

bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求
                               //题目要求保留两位小数，则eps取1e-4(比题目多两位)
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}

高精度[暂放]

高精度加法

// C = A + B, A >= 0, B >= 0
vector<int> add(vector<int> &A, vector<int> &B)
{
    if (A.size() < B.size()) return add(B, A);

    vector<int> C;
    int t = 0;
    for (int i = 0; i < A.size(); i ++ )
    {
        t += A[i];
        if (i < B.size()) t += B[i];
        C.push_back(t % 10);
        t /= 10;
    }

    if (t) C.push_back(t);
    return C;
}

高精度减法

// C = A - B, 满足A >= B, A >= 0, B >= 0
vector<int> sub(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    for (int i = 0, t = 0; i < A.size(); i ++ )
    {
        t = A[i] - t;
        if (i < B.size()) t -= B[i];
        C.push_back((t + 10) % 10);
        if (t < 0) t = 1;
        else t = 0;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

高精度乘低精度

// C = A * b, A >= 0, b >= 0
vector<int> mul(vector<int> &A, int b)
{
    vector<int> C;

    int t = 0;
    for (int i = 0; i < A.size() || t; i ++ )
    {
        if (i < A.size()) t += A[i] * b;
        C.push_back(t % 10);
        t /= 10;
    }

    while (C.size() > 1 && C.back() == 0) C.pop_back();

    return C;
}

高精度除以低精度

// A / b = C ... r, A >= 0, b > 0
vector<int> div(vector<int> &A, int b, int &r)
{
    vector<int> C;
    r = 0;
    for (int i = A.size() - 1; i >= 0; i -- )
    {
        r = r * 10 + A[i];
        C.push_back(r / b);
        r %= b;
    }
    reverse(C.begin(), C.end());
    while (C.size() > 1 && C.back() == 0) C.pop_back();
    return C;
}

前缀和与差分

前缀和：求区间和、求区域和

一维前缀和：数组下标[1]开始

S[i] = a[1] + a[2] + ... a[i]
S[i] = S[i - 1] + a[i] //求前i个数的和
a[l] + ... + a[r] = S[r] - S[l - 1] //求[l, r]的和

二维前缀和：数组下标[1,1]开始

S[i, j]含义：第i行j列格子左上部分所有元素的和([1,1]到[i,j]之间的和)
S[i, j] = S[i-1, j] + S[i, j-1] - S[i-1, j-1] + a[i, j]//第i行j列格子左上所有元素的和
以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：
S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]

差分：使区间元素都加C、使区域元素都加C

一维差分：数组下标[1]开始
思路：1.求差分数组：dif[i]=a[i]-a[i-1] ;
2.改变差分数组：dif[l]=dif[l]+c ; dif[r+1]=dif[r+1]-c ;
3.求原数组：a[i]=a[i-1]+dif[i];

给区间[l, r]中的每个数加上c：
dif[l] += c, 
dif[r + 1] -= c

二维差分：数组下标[1,1]开始
思路：1.求差分数组：func(i,j,i,j,a[i][j]);
2.改变差分数组：func(x1,y1,x2,y2,c);
3.求原数组：a[i][j] = a[i - 1][j] + a[i][j - 1] - a[i - 1][j - 1] + dif[i][j];

给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
dif[x1, y1] += c, 
dif[x2 + 1, y1] -= c, 
dif[x1, y2 + 1] -= c, 
dif[x2 + 1, y2 + 1] += c

双指针算法

时间复杂度：O(N)

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;

    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间(快指针i,慢指针j)
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作(两个指针，要么同方向移	动，要么相反方向，要看题目)

位运算

求n的第k位数字: n >> k & 1     
例：4=100  最右边是第0位，k要从0开始

返回n的最后一位1：lowbit(n) = n & -n
例：10=1010  lowbit(10)=2=10

离散化

思路：将大下标映射成小下标
数值 [3， 6， 1， 4， 9]
大下标 [1, 10, 100, 1500, 9999]
小下标 [1, 2, 3, 4, 5]
alls存放大下标，然后alls排序+去重，当使用到大下标时，使用二分返回小下标的值。即alls[1]->a[1],alls[10]->a[2],alls[100]->a[3]…

vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素

// 二分求出x对应的离散化的值
int find(int x) // 找到第一个大于等于x的位置
{
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

合并区间

思路：先按左端点排序，再维护一个区间A，与后面一个个区间B进行三种情况的比较，更新st,ed值。

区间A:[5,10]	st=5,ed=10
情况1：区间B：[6,9]	st=5,ed=max(9,10)=10	更新ed
情况2：区间B：[6,11]	st=5,ed=max(10,11)=11	更新ed
情况3：区间B：[12,13]	区间A加入res, 更新st=12,ed=13	更新st,ed

合并情况1+情况2 ==> ed =max(ed,segs[i].second);
情况3 ==>区间A加入res，st=segs[i].first,ed=segs[i].second;

// 将所有存在交集的区间合并
void merge(vector<PII> &segs)
{
    sort(segs.begin(),segs.end());
    vector<PII> res;
    
    int st=segs[0].first,ed=segs[0].second;//第一个区间
    for (int i = 1; i < segs.size(); i ++ )//处理中间[2...n-1]区间
    {
        if(ed<segs[i].first)
        {
            res.push_back({st,ed});
            st=segs[i].first,ed=segs[i].second;
        }
        else 
        {
            ed=max(ed,segs[i].second);
        }
    }
    res.push_back({st,ed});//处理最后一个区间
    segs=res;
}

单链表

[注意:]第一次插入、第二次插入、第三次插入分别对应idx=0,idx=1,idx=2

// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;

// 初始化
void init()
{
    head=-1;
    idx=0;
}
// 在链表头插入一个数x
void add_head(int x)
{
    e[idx]=x;
    ne[idx] = head;
    head = idx;
    idx++;
}
//idx=k的点之后插入一个数x
void add(int k,int x)
{
    e[idx]=x;
    ne[idx] = ne[k];
    ne[k]=idx;
    idx++;
}
// 将头结点删除，需要保证头结点存在
void remove_head()
{
    head=ne[head];
}
//删除idx=k的点
void remove(int k)
{
    ne[k]=ne[ne[k]];
}

双链表

[注意:]第一次插入、第二次插入、第三次插入分别对应idx=2,idx=3,idx=4

// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int l[N],r[N],e[N],idx;

// 初始化
void init()
{
    r[0]=1,l[1]=0,idx=2;//0是左端点，1是右端点
}

//idx=k的结点后插入
void add(int k,int x)
{
    e[idx]=x;
    l[idx]=k;
    r[idx]=r[k];
    l[r[k]]=idx;
    r[k]=idx;
    idx++;
}

//删除idx=k的结点
void remove(int k)
{
    l[r[k]]=l[k];
    r[l[k]]=r[k];
}

栈

// tt表示栈顶
int stk[N], tt = 0;

// 向栈顶插入一个数，从stk[1]开始
stk[ ++ tt] = x;

// 从栈顶弹出一个数
tt -- ;

// 栈顶的值
stk[tt];

// 判断栈是否为空，如果 tt > 0，则表示不空
if (tt > 0)
{

}

stack, 栈
    size()
    empty()
    push() 向栈顶插入一个元素
    top()  返回栈顶元素
    pop()  弹出栈顶元素

队列

1.普通队列：

// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;

// 向队尾插入一个数
q[ ++ tt] = x;

// 从队头弹出一个数
hh ++ ;

// 队头的值
q[hh];

// 判断队列是否为空，如果 hh <= tt，则表示不为空
if (hh <= tt)
{

}

queue, 队列
    size()
    empty()
    push()  向队尾插入一个元素
    front()  返回队头元素
    back()  返回队尾元素
    pop()  弹出队头元素

2.循环队列

// hh 表示队头，tt表示队尾的后一个位置
int q[N], hh = 0, tt = 0;

// 向队尾插入一个数
q[tt ++ ] = x;
if (tt == N) tt = 0;

// 从队头弹出一个数
hh ++ ;
if (hh == N) hh = 0;

// 队头的值
q[hh];

// 判断队列是否为空，如果hh != tt，则表示不为空
if (hh != tt)
{

}

单调栈

常见模型：找出每个数左边离它最近的比它大/小的数

stack<int> st;

for(int i=1;i<=n;i++)
{
    //出栈：栈顶一定不会作为答案输出
    while(!st.empty()&&check(st.top(),i))st.pop();
	//入栈
    st.push(i);
    //a[st.top()]就是答案
}

int st[N],tt=0;

for(int i=1;i<=n;i++)
{
    while(tt&&check(st[tt],i))tt--;
    st[++tt]=i;
    //a[st[tt]]就是答案
}

//找出数左边离它最近的比它小的数
bool check(int top_i,int i)
{
	return a[top_i]>=a[i] ? true : false ;
}

单调队列

常见模型：找出滑动窗口中的最大值/最小值

deque<int> q;

for(int i=0;i<n;i++)
{
    //弹出队头:队头滑出窗口
    if(!q.empty()&&check_out(q.front(),i)) q.pop_front();
    //弹出队尾：队尾一定不会作为答案输出
    while(!q.empty()&&check(q.back(),i)) q.pop_back();
    //入队尾
    q.push_back(i);
    //a[q.front()]就是答案
}

int hh = 0, tt = -1;
for (int i = 0; i < n; i ++ )
{
    while (hh <= tt && check_out(q[hh],i)) hh ++ ;
    while (hh <= tt && check(q[tt], i)) tt -- ;
    q[ ++ tt] = i;
    //a[q[tt]]就是答案
}

//找出滑动窗口中的最小值
bool check(int back_i,int i)
{
	return a[back_i]>a[i] ? true : false ;
}

KMP

// s[]是长文本，p[]是模式串，n是s的长度，m是p的长度,字符串s、p下标1开始
//求模式串的Next数组：
for (int i = 2, j = 0; i <= m; i ++ )
{
    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 <= n; i ++ )
{
    while (j && s[i] != p[j + 1]) j = ne[j];
    if (s[i] == p[j + 1]) j ++ ;
    if (j == m)
    {
        j = ne[j];
        // 匹配成功后的逻辑
    }
}

Trie树

Trie树又称字典树、单词查找树。是一种能够高效存储和查找字符串集合的数据结构。
在这里插入图片描述

Son[p][u]的含义：
1.p的含义：父节点编号p
2.u的含义：子节点存储字母u
3.son[p][u]的含义：子节点存储字母u的节点编号
应用：Trie字符串统计、最大异或对

int son[N][26], cnt[N], idx=0;
// 0号点既是根节点，又是空节点
// son[][]存储树中每个节点的子节点
// cnt[]存储以每个节点结尾的单词数量

// 插入一个字符串
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];
}

并查集

(1)朴素并查集：

    int p[N]; //存储每个点的祖宗节点

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ ) p[i] = i;

    // 合并a和b所在的两个集合：pa为pb的子节点
    p[find(a)] = find(b);


(2)维护size的并查集：

    int p[N], size[N];
    //p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量

    // 返回x的祖宗节点
    int find(int x)
    {
        if (p[x] != x) p[x] = find(p[x]);
        return p[x];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        size[i] = 1;
    }

    // 合并a和b所在的两个集合：siz[find(a)]是a所在集合的个数
    size[find(b)] += size[find(a)];
    p[find(a)] = find(b);


(3)维护到祖宗节点距离的并查集：

    int p[N], d[N];
    //p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离

    // 返回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];
    }

    // 初始化，假定节点编号是1~n
    for (int i = 1; i <= n; i ++ )
    {
        p[i] = i;
        d[i] = 0;
    }

    // 合并a和b所在的两个集合：
    p[find(a)] = find(b);
	// 根据具体问题，初始化a集合根节点==find(a)的偏移量
    d[find(a)] = distance;

堆[暂放]

// h[N]存储堆中的值, h[1]是堆顶，x的左儿子是2x, 右儿子是2x + 1
// ph[k]存储第k个插入的点在堆中的位置
// hp[k]存储堆中下标是k的点是第几个插入的
int h[N], ph[N], hp[N], size;

// 交换两个点，及其映射关系
void heap_swap(int a, int b)
{
    swap(ph[hp[a]],ph[hp[b]]);
    swap(hp[a], hp[b]);
    swap(h[a], h[b]);
}

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;
    if (u != t)
    {
        heap_swap(u, t);
        down(t);
    }
}

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

// O(n)建堆
for (int i = n / 2; i; i -- ) down(i);

一般哈希

(1) 拉链法
    int h[N], e[N], ne[N], idx;//N:大于数据范围的第一个质数
	memset(h, -1, sizeof h);
	
    // 向哈希表中插入一个数
    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;
    }

(2) 开放寻址法
    int h[N];//N:大于数据范围2~3倍的第一个质数
	memset(h, 0x3f, sizeof h);
		
    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
    int find(int x)
    {
        int t = (x % N + N) % N;
        //const int null = 0x3f3f3f3f;
        while (h[t] != null && h[t] != x)
        {
            t ++ ;
            if (t == N) t = 0;
        }
        return t;
    }

字符串哈希[字符串利器]

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

typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化 字符串下标1开始
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

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

STL

vector, 变长数组，倍增的思想
    size()  返回元素个数
    empty()  返回是否为空
    clear()  清空
    front()/back()
    push_back()/pop_back()
    begin()/end()
    []
    支持比较运算，按字典序

pair<int, int>
    first, 第一个元素
    second, 第二个元素
    支持比较运算，以first为第一关键字，以second为第二关键字（字典序）

string，字符串
    size()/length()  返回字符串长度
    empty()
    clear()
    substr(起始下标，(子串长度))  返回子串
    c_str()  返回字符串所在字符数组的起始地址

queue, 队列
    size()
    empty()
    push()  向队尾插入一个元素
    front()  返回队头元素
    back()  返回队尾元素
    pop()  弹出队头元素

priority_queue, 优先队列，默认是大根堆
    size()
    empty()
    push()  插入一个元素
    top()  返回堆顶元素
    pop()  弹出堆顶元素
    定义成小根堆的方式：priority_queue<int, vector<int>, greater<int>> q;

stack, 栈
    size()
    empty()
    push()  向栈顶插入一个元素
    top()  返回栈顶元素
    pop()  弹出栈顶元素

deque, 双端队列
    size()
    empty()
    clear()
    front()/back()
    push_back()/pop_back()
    push_front()/pop_front()
    begin()/end()
    []

set, map, multiset, multimap, 基于平衡二叉树（红黑树），动态维护有序序列
    size()
    empty()
    clear()
    begin()/end()
    ++, -- 返回前驱和后继，时间复杂度 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, 圧位
    bitset<10000> s;
    ~, &, |, ^
    >>, <<
    ==, !=
    []

    count()  返回有多少个1

    any()  判断是否至少有一个1
    none()  判断是否全为0

    set()  把所有位置成1
    set(k, v)  将第k位变成v
    reset()  把所有位变成0
    flip()  等价于~
    flip(k) 把第k位取反

树与图的存储

树是一种特殊的图，与图的存储方式相同。
对于无向图中的边ab，存储两条有向边a->b, b->a。
因此我们可以只考虑有向图的存储。

(1) 邻接矩阵-稠密图（m=n）：g[a][b] 存储边a->b
(2) 邻接表-稀疏图（m=$n^2\$）：

// N个顶点、M条边
int h[N], e[M], ne[M], w[M], idx;

// 添加一条边a->b
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}

// 添加一条边a->b,权重c
void add(int a, int b, int c)
{
    e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx ++ ;
}

// 初始化
idx = 0;
memset(h, -1, sizeof h);//只有0、-1、0x3f、true、false能准确赋值

树与图的遍历

时间复杂度 O(n+m), n表示点数，m表示边数
(1) 深度优先遍历
应用：

int dfs(int u)
{
    st[u] = true; // st[u] 表示点u已经被遍历过

    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j]) dfs(j);
    }
}

(2) 宽度优先遍历

846.图中点的层次：给的是add(a,b)边关系=>遍历邻接表
844.走迷宫：给得是地图=>遍历地图
邻接表：

queue<int> q;
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);
            //具体逻辑
        }
    }
}

地图：

queue<pair<int,int>>q;
st[0][0]=true;
q.push({0,0});

while(!q.empty())
{
    auto t=q.front();
    q.pop();
    for(int i=0;i<4;i++)
    {
        int x=t.first+dx[i];
        int y=t.second+dy[i];
        if(!st[x][y]&& XXX )
        {
            st[x][y]=true;
            q.push({x,y});
			//具体逻辑
        }
    } 
}

拓扑排序

时间复杂度 O(n+m), n 表示点数，m表示边数
应用：拓扑序列、判定有向图是否有环

bool topsort()
{
    // d[i] 存储点i的入度
    queue<int> q;
    for(int i = 1;i <= n; i ++)
        if(!d[i])
            q.push(i);

    while (!q.empty())
    {
        int t = q.front();
        q.pop();
		
        //将队列队头元素加入top[],初始化cnt=0
        top[cnt++]=t;
        
        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (-- d[j] == 0)
                q.push(j);
        }
    }

    // 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
    return cnt == n ;
}

最短路总结：

优先使用spfa,不行，就堆优化dijkstra算法
在这里插入图片描述

（1）邻接矩阵存储需要处理自环、重边（仅朴素dijkstra算法、floyd算法）：

//1.初始化
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;
2.//数据输入时处理自环、重边
if(a==b)g[a][b]=0;//自环
else g[a][b]=min(g[a][b],w);//重边

（2）邻接表、结构体存储不需要处理自环、重边

朴素Dijkstra算法：

适用范围：所有边正权、稠密图、m=n^2
时间复杂度：O(n)
如何存储：邻接矩阵+处理自环和重边

思路：
集合S：当前已经确定最短距离得点
1.dist[1]=0,dist[i]=正无穷   其中i!=1 
2.循环for(1~n)次
	2.1 t <- 没有确定最短路径的节点[不在集合S中的点]中距离源点最近的点;
    2.2 将 t 加入集合 S
    2.3 更新 dist;

堆优化Dijkstra：

适用范围：所有边正权、稀疏图、m=n
时间复杂度：O(m log(n) )
如何存储：邻接表

优化点：堆优化版的dijkstra是对朴素版dijkstra优化，在朴素版dijkstra中时间复杂度最高的2.1步骤寻找距离最短点O(n^2)可以使用最小堆优化。
1.dist[1]=0,dist[i]=正无穷   其中i!=1
2. 将一号点放入堆中，不断循环，直到堆空
    2.1 弹出堆顶，即最短距离。
    2.2 判断堆顶元素是否在集合S中，在，continue,不在，进行2.3
    2.3 用该点更新临界点的距离，若更新成功就加入到堆中。

Bellman-ford算法：

(1)负权求最短路：最多经过 k 条边的最短距离**(可以存在负环)**

适用范围：负权、最多经过 k 条边、可以负环
时间复杂度：O(nm)
如何存储：邻接表

优化点：从dijkstra算法的由点找边变为Bellman算法的直接遍历边来更新值，其用来处理限制边数的相关问题，整体过程如下：
1.限制要走的边数
2.备份上一轮更新后的距离
2.遍历所有边，并且用走的边来更新距离，但是要注意的是更新距离的时候要使用备份距离数据

~~(2)判负环（不推荐使用）~~

适用范围：判负环
时间复杂度：O(nm)
如何存储：邻接表

spfa算法：

(1)负权求最短路

适用范围：负权、不可以负环
时间复杂度：平均情况O(m) 最坏情况O(nm)
如何存储：邻接表

优化点：bellman算法是遍历所有边，无论该边之前的距离是否发生改变，spfa算法就根据这一点进行优化，只有前面的边的最短距离发生变化，其后面跟着的边最短距离才可能发生变化，用queue存dist变小的点。

spfa算法的st数组不再像dijkstra算法用于标记该点的最短距离是否已经确定，而是标记该点的距离是否发生了变化，发生了变化就要入队用其更新后面点的最短距离。

(2)判负环（推荐使用）

适用范围：判负环
时间复杂度：O(nm)
如何存储：邻接表

floyd算法：

适用范围：多源最短路问题、可以负权、不能负环
时间复杂度：O(n^3)
如何存储：邻接矩阵+处理自环和重边

朴素dijkstra算法

适用：稠密图m=$n^2\ $, 邻接矩阵 [需要处理自环、重边] 时间复杂度 O ($ n^2\$+m)=O($n2\ $+$ n^2\$)=O($n2\$), n 表示点数，m表示边数

int g[N][N];  // 存储每条边
int dist[N];  // 存储1号点到每个点的最短距离
bool st[N];   // 存储每个点的最短路是否已经确定

// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for (int i = 1; i <= n ; i ++ )
    {
        int t = -1; // 在还未确定最短路的点中，寻找距离最小的点
        for (int j = 1; j <= n; j ++ )
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;

        // 用t更新其他点的距离
        for (int j = 1; j <= n; j ++ )
            dist[j] = min(dist[j], dist[t] + g[t][j]);

        st[t] = true;
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

堆优化版dijkstra

适用：稀疏图m=n,邻接表
时间复杂度 O(mlogn), n表示点数，m 表示边数

typedef pair<int, int> PII;

int n;      // 点的数量
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N];        // 存储所有点到1号点的距离
bool st[N];     // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    
    priority_queue<PII, vector<PII>, greater<PII>> heap;
    heap.push({0, 1});// first存储距离，second存储节点编号

    while (heap.size())
    {
        auto t = heap.top();
        heap.pop();

        int ver = t.second, distance = t.first;

        //优先队列中会存在冗余信息，一个点更新(存入)两次dist
        if (st[ver]) continue;
        st[ver] = true;

        for (int i = h[ver]; i != -1; i = ne[i])
        {
            int j = e[i];
            if (dist[j] > distance + w[i])
            {
                dist[j] = distance + w[i];
                heap.push({dist[j], j});
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;
    return dist[n];
}

Bellman-Ford算法

适用：最多经过 k 条边的最短距离**(可以存在负环)**
时间复杂度 O(nm), n表示点数，m 表示边数

//最多经过 k 条边的最短距离

int n, m;       // n表示点数，m表示边数
int dist[N],backup[N];        // dist[x]存储1到x的最短路距离

struct Edge     // 边，a表示出点，b表示入点，w表示边的权重
{
    int a, b, w;
}edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回0x3f3f3f3f。
int bellman_ford()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    for(int i=1;i<=k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        for(int j=1;j<=m;j++)
        {
            int a=edg[j].a,b=edg[j].b,w=edg[j].w;
            if(dist[b]>backup[a]+w)
            {
                dist[b] = backup[a]+w;    
            }
        }
    }

    if (dist[n] > 0x3f3f3f3f / 2) return 0x3f3f3f3f;
    return dist[n];
}

Bellman-Ford判负环

适用：判断负环（不推荐使用Bellman-ford判负环、推荐spfa）
时间复杂度 O(nm), n表示点数，m 表示边数

int dist[N],backup[N];
struct
{
    int a,b,w;
}edg[N];

int bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    bool flag;
     // 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
    for(int i=1;i<=n;i++)
    {
        flag = false;
        memcpy(backup,dist,sizeof dist);
        for(int j=1;j<=m;j++)
        {
            int a=edg[j].a,b=edg[j].b,w=edg[j].w;
            if(dist[b]>backup[a]+w)
            {
                dist[b]=backup[a]+w;
                flag = true;
            }
        }
    }
    
    if(flag)return 1;//有负环
    else return 0;//无负环
}

spfa 算法（队列优化的Bellman-Ford算法）

适用：存在负权边求最短距离**（不能存在负环）**
时间复杂度平均情况O(m) 最坏情况O(nm) , n表示点数，m 表示边数

int n;      // 总点数
int h[N], w[M], e[M], ne[M], idx;       // 邻接表存储所有边
int dist[N];        // 存储每个点到1号点的最短距离
bool st[N];     // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;

    queue<int> q;//存储dist变小的节点
    q.push(1);
    st[1] = true;

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

        st[t] = false;

        for (int i = h[t]; i != -1; i = ne[i])
        {
            int j = e[i];
            //dist变小、加入queue
            if (dist[j] > dist[t] + w[i])
            {
                dist[j] = dist[t] + w[i];
                if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    if (dist[n] == 0x3f3f3f3f) return -1;//不存在
    return dist[n];///存在
}

spfa判负环

时间复杂度 O(nm) , n表示点数，m 表示边数

int n;      // 总点数
int h[N], w[N], e[N], ne[N], idx;       // 邻接表存储所有边
int dist[N], cnt[N];        // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N];     // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
    // 不需要初始化dist数组
    // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

    queue<int> q;
    for (int i = 1; i <= n; i ++ )
    {
        q.push(i);
        st[i] = true;
    }

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

        st[t] = false;

        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];
                cnt[j] = cnt[t] + 1;
                //如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
                if (cnt[j] >= n) return true;
                if (!st[j])
                {
                    q.push(j);
                    st[j] = true;
                }
            }
        }
    }

    return false;
}

floyd算法

适用：多源最短路、可以负权、邻接矩阵[需要处理自环、重边]
时间复杂度 O($n^3\$) , n表示点数

初始化：
    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;//INF = 0x3f3f3f3f;

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

//不存在最短路
d[x][y] >= INF/2

最小生成树总结：

(1)朴素版prim算法思想：从某个点出发，并将这个点纳入集合，每次找到离集合最近的点，纳入集合，并且更新未纳入集
合的点到集合的距离

S:当前已经在联通块中的所有点的集合
1. dist[i] = inf
2. for n 次
    t<-S外离S最近的点
    st[t] = true
    利用t更新S外点到S的距离
n次迭代之后所有点都已加入到S中
联系：Dijkstra算法是更新到起始点的距离，Prim是更新到集合S的距离

(2)Kruskal思想：排序，每次取未纳入集合并且最小的边，将其纳入集合中，直到所有点都纳入到集合中

将所有边按照权重从小到大排序 O(mlogm)
枚举每条边(a, b， 权重c) O(m)
      if a, b 两点不在一个集合
            1.将a、b点合并一个集合（相当于ab的边用了）
            2.cnt记录边数

朴素版prim算法

适用：无向图、稠密图、m=n^2、邻接矩阵[需要处理自环、重边]
时间复杂度 O($n^2+m\ $) = O ($ n²⁺ⁿ2\ $) = O ($ n^2\$) , n表示点数，m 表示边数

int n;      // n表示点数
int g[N][N];        // 邻接矩阵，存储所有边
int dist[N];        // 存储其他点到当前最小生成树的距离
bool st[N];     // 存储每个点是否已经在生成树中


// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
    memset(dist, 0x3f, sizeof dist);

    int res = 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;

        if (i && dist[t] == INF) return INF;

        if (i) res += dist[t];
        st[t] = true;

        for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
    }

    return res;
}

Kruskal算法

适用：无向图、稀疏图、m=n、结构体
时间复杂度O(m logm) , m 表示边数

int n, m;       // n是点数，m是边数
int p[N];       // 并查集的父节点数组

struct Edge     // 存储边
{
    int a, b, w;

    bool operator< (const Edge &W)const
    {
        return w < W.w;
    }
}edges[M];

int find(int x)     // 并查集核心操作
{
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edges, edges + m);

    for (int i = 1; i <= n; i ++ ) p[i] = i;    // 初始化并查集

    int res = 0, cnt = 0;
    for (int i = 0; i < m; i ++ )
    {
        int a = edges[i].a, b = edges[i].b, w = edges[i].w;

        a = find(a), b = find(b);
        if (a != b)     // 如果两个连通块不连通，则将这两个连通块合并
        {
            p[a] = b;
            res += w;
            cnt ++ ;
        }
    }

    if (cnt < n - 1) return INF;//不连通
    return res;//连通
}

二分图总结：

(1)染色法判断二分图
二分图可以是连通图、非连通图；

思路：
1.开始对任意一未染色的顶点染色。
2.判断其相邻的顶点中，
	2.1 若未染色，则将其染上和相邻顶点不同的颜色，递归dfs(j,!c)判断。
	2.2 若已经染色，且颜色和相邻顶点的颜色相同则说明不是二分图，若颜色不同则继续判断。
	
注意：无向图、邻接表、存在重边和自环。
	自环则不是二分图,算法自动判断。

(2)匈牙利算法

思路：
	男c匹配女a,若女a已经有男b，则让男b另找女
    1.男b找不到-->那就单身； (女a,男c)(男b,空)
    2.男b找到了-->那就匹配； (女a,男c)(男b,女)

注意：无向图==>存一条有向边
    遍历n1集合的点，则存n1->n2的边
    
重点:st[]的作用:
首先我们 find(x) 遍历属于h[x]的单链表相当于遍历他所有喜欢的女生
  而如果某个女生j没有被他预定过的话
  就标记这个女生j被他预定,即st[j]=true
这时如果女j还没有匹配过,即match[j]==0的时候,那这个预定就成真了,得到match[j]=x;
  而如果女j之前就被男k匹配过了,那我们就find(k),也就是
  find(match[j])(因为原本match[j]==k)
然后在find(k)的过程中,因为st[j]=true,这时候男k就不能再选则女j了,因为女j已经被预定了,
所以男k就只能在他喜欢的女生里面选择其他人来匹配。 当然，如果find(k)返回false的话,
那就 if(match[j]==0 || find(match[j]))都不成立,那男j就一边玩去吧

染色法判别二分图

适用：判别是否是二分图、邻接表
时间复杂度 O(n+m), n表示点数，m 表示边数

int n;      // n表示点数
int h[N], e[M], ne[M], idx;     // 邻接表存储图
int color[N];       // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色

// 颜色过程：u表示当前节点，c表示当前点的颜色
bool dfs(int u, int c)
{
    color[u] = c;
    for (int i = h[u]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (color[j] == -1)//未染色
        {
            if (!dfs(j, !c))//把j染成相反颜色!c，false则失败 
                return false;
        }
        else //已染色
        {
			if (color[j] == c) //u、j颜色相同,失败
                return false;
        }
    }
    return true;
}


//返回true,是二分图；false,不是二分图
bool check()
{
    memset(color, -1, sizeof color);
    bool flag = true;
    for (int i = 1; i <= n; i ++ )
        if (color[i] == -1)//未染色
            if (!dfs(i, 0))//染色失败（0/1都可以）
            {
                flag = false;
                break;
            }
    return flag;
}

匈牙利算法

适用：求二分图的最大匹配数（最多能有几对情侣）、邻接表
时间复杂度 O(nm), n表示点数，m 表示边数

int n1, n2;     // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx;     
// 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边；  遍历n1集合的点，则存n1->n2的边      
int match[N];       // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N];     // 表示第二个集合中的每个点是否已经被遍历过

bool find(int x)
{
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!st[j])//女j还没有考虑过
        {
            st[j] = true;//
            //女j没有匹配||可以帮女j找到下家
            if (match[j] == 0 || find(match[j]))
            {
                match[j] = x;
                return true;
            }
        }
    }

    return false;
}

// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
    memset(st, false, sizeof st);
    if (find(i)) res ++ ;
}

试除法判定质数

时间复杂度：O( $\sqrt{n}$ )

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

试除法分解质因数

适用：将一个数分解成多个质数相乘。
时间复杂度：O( $\sqrt{n}$ )

void divide(int x)
{
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)//此时i是质数
        {
            int s = 0;
            while (x % i == 0) x /= i, s ++ ;
            cout << i << ' ' << s << endl;
        }
    // x中最多包含一个大于sqrt(x) 的质因数
    if (x > 1) cout << x << ' ' << 1 << endl;
    cout << endl;
}
//i为质数的原因：
//若i为合数，则可以分解成多个质数相乘，并且仅有一个最大质因数>=sqrt(i)
//i = p1*p2*p3...pi...pn
// 2 <= pi < i
//所以x在进行while时已将x=x/pi,所以i一定是质数

朴素筛法求素/质数

适用：将1~n范围所有质数存入primes数组
又称诶氏筛法，时间复杂度：O(n loglogn )

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])//i是质数
        {
            primes[cnt ++ ] = i;
            for (int j = i + i; j <= n; j += i)
                st[j] = true;   
        }
    }
}

线性筛法求素/质数（推荐）

适用：将1~n范围所有质数存入primes数组，在n=1e6两者一样、n=1e7时线性筛快一倍
时间复杂度：O(n)

int primes[N], cnt;     // primes[]存储所有素数
bool st[N];         // st[x]存储x是否被筛掉

void get_primes(int n)
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;//质数
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}

试除法求所有约数

vector<int> get_divisors(int x)
{
    vector<int> res;
    for (int i = 1; i <= x / i; i ++ )
        if (x % i == 0)//约数
        {
            res.push_back(i);
            //egg:36,当i=6时，只加入一次36/i
            if (i != x / i) res.push_back(x / i);
        }
    sort(res.begin(), res.end());
    return res;
}

约数个数、约数之和

如果 N = p1^c1 * p2^c2 * ... *pk^ck
约数个数： (c1 + 1) * (c2 + 1) * ... * (ck + 1)
约数之和： (p1^0 + p1^1 + ... + p1^c1) * ... * (pk^0 + pk^1 + ... + pk^ck)

unordered_map<int,int> primes;//int 质数;int 指数

//分解质因数
void divide(int n)
{   
    for (int i = 2; i <= n / i; i ++ )
    {
        if(n%i==0)//i是质数
        {
            while (n % i == 0)
            {
                n /= i;
                primes[i] ++ ;
            }
        }
    }
    // x中最多包含一个大于sqrt(x) 的质因数
    if (n > 1) primes[n] ++ ;
}

//for(auto p:primes) p.first p.second

欧几里得算法

最大公约数,0和任何自然数a的最大公约数是a

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

求欧拉函数

适用：1∼N 中与 N 互质的数的个数被称为欧拉函数，记为 ϕ(N)。
欧拉定理：对任意两个正整数 a , n，若两者互质，则： $a^{\phi (n)}\equiv 1\pmod n$ ；<===> $\phi (n)$ %n = 1
时间复杂度：O( $\sqrt{n}$ )

int phi(int x)
{
    int res = x;
    for (int i = 2; i <= x / i; i ++ )
        if (x % i == 0)
        {
            res = res / i * (i - 1);
            while (x % i == 0) x /= i;
        }
    if (x > 1) res = res / x * (x - 1);

    return res;
}

筛法求欧拉函数

适用：求 1∼n 中每个数的欧拉函数
时间复杂度：O(n)

int primes[N], cnt;     // primes[]存储所有素数
int euler[N];           // 存储每个数的欧拉函数
bool st[N];         // st[x]存储x是否被筛掉


void get_eulers(int n)
{
    euler[1] = 1;
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i])
        {
            primes[cnt ++ ] = i;
            euler[i] = i - 1;
        }
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            int t = primes[j] * i;
            st[t] = true;
            if (i % primes[j] == 0)
            {
                euler[t] = euler[i] * primes[j];
                break;
            }
            euler[t] = euler[i] * (primes[j] - 1);
        }
    }
}

快速幂

求 m^k mod p，时间复杂度 O(logk)。

int qmi(int m, int k, int p)
{
    int res = 1 % p, t = m;
    while (k)
    {
        if (k&1) res = res * t % p;
        t = t * t % p;
        k >>= 1;
    }
    return res;
}

扩展欧几里得算法

// 求出一组x, y，使得ax + by = gcd(a, b)
int exgcd(int a, int b, int &x, int &y)
{
    if (!b)
    {
        x = 1; y = 0;
        return a;
    }
    int d = exgcd(b, a % b, y, x);
    y -= (a/b) * x;
    return d;
}

高斯消元

适用：包含n个方程，n个未知数的多元线性方程组 ,增广矩阵a[n][n+1]
时间复杂度：O( $n^3$ )

// a[N][N]是增广矩阵
int gauss()
{
    int c, r;
    for (c = 0, r = 0; c < n; c ++ )
    {
        int t = r;
        for (int i = r; i < n; i ++ )   // 找到绝对值最大的行
            if (fabs(a[i][c]) > fabs(a[t][c]))
                t = i;

        if (fabs(a[t][c]) < eps) continue;

        for (int i = c; i <= n; i ++ ) swap(a[t][i], a[r][i]);      // 将绝对值最大的行换到最顶端
        for (int i = n; i >= c; i -- ) a[r][i] /= a[r][c];      // 将当前行的首位变成1
        for (int i = r + 1; i < n; i ++ )       // 用当前行将下面所有的列消成0
            if (fabs(a[i][c]) > eps)
                for (int j = n; j >= c; j -- )
                    a[i][j] -= a[r][j] * a[i][c];

        r ++ ;
    }

    if (r < n)
    {
        for (int i = r; i < n; i ++ )
            if (fabs(a[i][n]) > eps)
                return 2; // 无解
        return 1; // 有无穷多组解
    }

    for (int i = n - 1; i >= 0; i -- )
        for (int j = i + 1; j < n; j ++ )
            a[i][n] -= a[i][j] * a[j][n];

    return 0; // 有唯一解
}



if (t == 0)
    for (int i = 0; i < n; i ++ ) printf("%.2lf\n", a[i][n]);
else if (t == 1) puts("Infinite group solutions");
else puts("No solution");

递推法求组合数

$C^b_a$ = $C^{b-1}_{a−1}$ + $C^b_{a−1}$
时间复杂度：O( $n^2$ )
数据范围：1≤b≤a≤2000

// c[a][b] 表示从a个苹果中选b个的方案数
for (int i = 0; i < N; i ++ )
    for (int j = 0; j <= i; j ++ )
        if (!j) c[i][j] = 1;
        else c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;

通过预处理逆元的方式求组合数

时间复杂度：O(nlogn)
数据范围：1≤b≤a≤ $10^5$

在这里插入图片描述

首先预处理出所有阶乘取模的余数fact[N]，以及所有阶乘取模的逆元infact[N]
关键：如果取模的数mod是质数，可以用费马小定理求逆元
int qmi(int a, int k, int p)    // 快速幂模板
{
    int res = 1;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

// 预处理阶乘的余数和阶乘逆元的余数
fact[0] = infact[0] = 1;
for (int i = 1; i < N; i ++ )
{
    fact[i] = (LL)fact[i - 1] * i % mod;
    infact[i] = (LL)infact[i - 1] * qmi(i, mod - 2, mod) % mod;
}

//C(a,b)=  a中选b个
C(a,b) = (LL)fact[a] * infact[b] % mod * infact[a - b] % mod

Lucas定理

时间复杂度：O(nlogn)
数据范围：1 ≤ b ≤ a ≤ $10^{18}$ 1 ≤ p ≤ $10^{5}$

若p是质数，则对于任意整数 1 <= m <= n，有：
    C(n, m) = C(n % p, m % p) * C(n / p, m / p) (mod p)

int qmi(int a, int k, int p)  // 快速幂模板
{
    int res = 1 % p;
    while (k)
    {
        if (k & 1) res = (LL)res * a % p;
        a = (LL)a * a % p;
        k >>= 1;
    }
    return res;
}

int C(int a, int b, int p)  // 通过定理求组合数C(a, b)
{
    if (a < b) return 0;

    LL x = 1, y = 1;  // x是分子，y是分母
    for (int i = a, j = 1; j <= b; i --, j ++ )
    {
        x = (LL)x * i % p;
        y = (LL) y * j % p;
    }

    return x * (LL)qmi(y, p - 2, p) % p;
}

int lucas(LL a, LL b, int p)
{
    if (a < p && b < p) return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;
}

//C(a,b) 
C(a,b) = lucas(a,b,p)

分解质因数法求组合数

数据范围：1≤b≤a≤5000

当我们需要求出组合数的真实值，而非对某个数的余数时，分解质因数的方式比较好用：
    1. 筛法求出范围内的所有质数
    2. 通过 C(a, b) = a! / b! / (a - b)! 这个公式求出每个质因子的次数。 n! 中p的次数是 n / p + n / p^2 + n / p^3 + ...
    3. 用高精度乘法将所有质因子相乘

int primes[N], cnt;     // 存储所有质数
int sum[N];     // 存储每个质数的次数
bool st[N];     // 存储每个数是否已被筛掉


void get_primes(int n)      // 线性筛法求素数
{
    for (int i = 2; i <= n; i ++ )
    {
        if (!st[i]) primes[cnt ++ ] = i;
        for (int j = 0; primes[j] <= n / i; j ++ )
        {
            st[primes[j] * i] = true;
            if (i % primes[j] == 0) break;
        }
    }
}


int get(int n, int p)       // 求n！中的次数
{
    int res = 0;
    while (n)
    {
        res += n / p;
        n /= p;
    }
    return res;
}


vector<int> mul(vector<int> a, int b)       // 高精度乘低精度模板
{
    vector<int> c;
    int t = 0;
    for (int i = 0; i < a.size(); i ++ )
    {
        t += a[i] * b;
        c.push_back(t % 10);
        t /= 10;
    }

    while (t)
    {
        c.push_back(t % 10);
        t /= 10;
    }

    return c;
}

get_primes(a);  // 预处理范围内的所有质数

for (int i = 0; i < cnt; i ++ )     // 求每个质因数的次数
{
    int p = primes[i];
    sum[i] = get(a, p) - get(b, p) - get(a - b, p);
}

vector<int> res;
res.push_back(1);

for (int i = 0; i < cnt; i ++ )     // 用高精度乘法将所有质因子相乘
    for (int j = 0; j < sum[i]; j ++ )
        res = mul(res, primes[i]);

卡特兰数

给定n个0和n个1，它们按照某种顺序排成长度为2n的序列，满足任意前缀中0的个数都不少于1的个数的序列的数量为： Cat(n) = C(2n, n) / (n + 1)

阿斯卡码

关注

30
点赞
踩
18

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录