算法基础 笔记
师从 yxc (算法大佬), http://www.acwing.com,大家可以去了解一下.
目录
特殊知识：C++ STL
第一章 基础算法
1 排序
1.1 快速排序
1.2 归并排序
2 二分
2.1 整数二分
2.2浮点数二分
3 高精度
3.1 高精度加法
3.2 高精度减法
3.3 高精度乘法(高精度乘以低精度)
3.4高精度除法(高精度除以低精度)
4 前缀和 和 差分
4.1 前缀和
4.2 差分
5 双指针算法
6 位运算
7 离散化
8 区间合并
第二章 数据结构
1 链表
1.1 单链表
1.2 双链表
2 栈
2.1 模拟栈
2.2 单调栈
3 队列
3.1 模拟普通队列
3.2 模拟循环队列
3.3 单调队列
4 KMP
5 Trie树
代码如下：
6 并查集
6.1 朴素并查集
6.2 维护size的并查集
6.3 维护到祖宗节点距离的并查集
7 堆
8 哈希表（hash表)
8.1 一般哈希（数字）
8.2 字符串哈希
第三章 图论
1 DFS（深度优先搜索）
2 BFS （宽度优先遍历）
3 树和图的存储与遍历
3.1 存储
3.2 遍历
4 拓扑排序
5 最短路
5.1 朴素 Dijkstra 算法
5.2 堆优化版 Dijkstra 算法
5.3 Bellman-Ford 算法
5.4 SPFA 算法
5.5 Floyd 算法
6 最小生成树
6.1 朴素 prim 算法
6.2 堆优化版 prim 算法
6.3 Kruskal算法
7 二分图
7.1 染色法
7.2 匈牙利算法
第四章 数学
1 质数
1.1 试除法判定质数
1.2 分解质因数
1.3 筛质数（线性筛）
2 约数
2.1 试除法求约数
2.2 约数个数
2.3 约数之和
2.4 最大公约数
3 欧拉函数
3.1 求欧拉函数
3.2 筛法求欧拉函数
4 快速幂
4.1 求快速幂
4.2 快速幂求逆元
5 扩展欧几里得算法
5.1 扩展欧几里得算法
5.2 线性同余方程
6 中国剩余定理
7 高斯消元
7.1 高斯消元解方程组
7.2 高斯消元解异或线性方程组
8 求组合数
8.1 组合数 I
8.2 组合数 II
8.3 组合数 III
8.4 组合数 IV
8.5 卡特兰数
9 容斥原理
10 博弈论
10.1 Nim游戏
10.2 台阶-Nim游戏
10.3 集合-Nim游戏
10.4 拆分-Nim游戏
第五章 动态规划
1 背包问题
2 线性DP
3 区间DP
4 计数类DP
5 数位统计DP
6 状态压缩DP
7 树形DP
8 记忆化搜索
第六章 贪心
特殊知识：C++ STL
vector, 变长数组，倍增的思想
size() 返回元素个数
empty() 返回是否为空
clear() 清空
front()/back()
push_back()/pop_back()
begin()/end()
[]
支持比较运算，按字典序
pair
first, 第一个元素
second, 第二个元素
支持比较运算，以first为第一关键字，以second为第二关键字（字典序）
string，字符串
size()/length() 返回字符串长度
empty()
clear()
substr(起始下标，(子串长度)) 返回子串
//substr有2种用法：
//假设：string s = "0123456789";
//string sub1 = s.substr(5);
//只有一个数字5表示从下标为5开始一直到结尾：sub1 = "56789"
//string sub2 = s.substr(5, 3);
//从下标为5开始截取长度为3位：sub2 = "567"
c_str() 返回字符串所在字符数组的起始地址
queue, 队列
size()
empty()
push() 向队尾插入一个元素
front() 返回队头元素
back() 返回队尾元素
pop() 弹出队头元素
priority_queue, 优先队列，默认是大根堆
size()
empty()
push() 插入一个元素
top() 返回堆顶元素
pop() 弹出堆顶元素
定义成小根堆的方式：priority_queue, greater> 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, 圧位
（详细例子可见https://blog.csdn.net/weixin_44235989/article/details/107825643）
bitset<10000> s;
~, &, |, ^
>>, <<
==, !=
[]
count() 返回有多少个1
any() 判断是否至少有一个1
none() 判断是否全为0
set() 把所有位置成1
set(k, v) 将第k位变成v
reset() 把所有位变成0
flip() 等价于~
flip(k) 把第k位取反
第一章 基础算法
1 排序
1.1 快速排序
模板如下:
void quick_sort(int q[], int l, int r)
{
if (l >= r) return;
//确定分界点
//x可为数组任意元素,一般性取x为(l+r)/2;
int x = q[l + r >> 1], i = l - 1, j = r + 1;
调整区间
while (i < j)
{
do i ++ ; while (q[i] < x);
do j -- ; while (q[j] > x);
if (i < j) swap(q[i], q[j]);
}
//递归处理左右两段
quick_sort(q, l, j);
quick_sort(q, j + 1, r);
}
1.2 归并排序
模板如下:
void merge_sort(int q[], int l, int r)
{
if (l >= r) 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;
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 二分
2.1 整数二分
//C++中有头文件algorithm，其中包括二分查找，lower_bound和upper_bound为二分法查找元素，其时间复杂度为O(log n)。
lower_bound：
用法：int i = lower_bound(nums, nums + n, val) - nums;//函数返回值为指针，要减去首地址。
函数解释：lower_bound函数返回数组 nums 中大于等于 val 的第一个元素的地址，若 nums 中的元素均小于 val 则返回尾后地址。
upper_bound：
用法：int i = upper_bound(nums, nums + n, val) - nums;//函数返回值为指针，要减去首地址。
函数解释：upper_bound函数返回数组 nums 中大于 val 的第一个元素的地址，若 nums 中的元素均小于等于 val 则返回尾后地址。
模板如下:
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 (check(mid)) r = mid; // check()判断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 (check(mid)) l = mid;//注:此处为l,mid应加1再除以2
else r = mid - 1;
}
return l;
}
2.2浮点数二分
模板如下:
bool check(double x) {/* ... */} // 检查x是否满足某种性质
double bsearch_3(double l, double r)
{
const double eps = 1e-6; // eps 表示精度，取决于题目对精度的要求
while (r - l > eps)
{
double mid = (l + r) / 2;
if (check(mid)) r = mid;
else l = mid;
}
return l;
}3 高精度
3.1 高精度加法
模板如下:
// C = A + B, A >= 0, B >= 0
vector add(vector &A, vector &B)
{
if (A.size() < B.size()) return add(B, A);
vector 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;
}
3.2 高精度减法
模板如下:
// C = A - B, 满足A >= B, A >= 0, B >= 0
vector sub(vector &A, vector &B)
{
vector 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;
}
3.3 高精度乘法(高精度乘以低精度)
模板如下:
// C = A * b, A >= 0, b >= 0
vector mul(vector &A, int b)
{
vector 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;
}
3.4高精度除法(高精度除以低精度)
模板如下:
// A / b = C ... r, A >= 0, b > 0
vector div(vector &A, int b, int &r)
{
vector 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;
}
3.5 高精度之压位
问： 高精度用 v e c t o r vectorvector 慢的一批，不管了（这题没啥意思，，）思路就是这样，有高人救一下否 ? ??
答： 高精度压位即可，i n t intint类型 只存 0~9 的一位数实在是浪费，并且速度还慢，i n t intint 类型习惯压 4 44 或 8 88 位，最多可以压 9 99 位。
注： 想学习高精度压位的，参考此博客：【算法专题】高精度之压位
4 前缀和 和 差分
前缀和与差分互为逆运算，其关系类似微分与积分；
4.1 前缀和
用途：简化求区间的和
一维前缀和
模板如下:
//a[n]是原数组, s[n]是前缀和数组, [l,r]为计算区间
//前缀和思想
//S[i] = a[1] + a[2] + ... a[i];
//输入原数组
for( int i = 1; i<=n; i++)
scanf("%d",&a[i]);
//计算前缀和数组
for( int i=1; i<=n; i++)
S[i] = S[i-1] + a[i];
//计算区间内元素的和
sum = S[r] - S[l-1] = a[l] + ... + a[r] ;二维前缀和
代码如下：
//输入原数组
for( int i = 1; i<=n; i++ )
for( int j = 1; j<=m; j++ )
scanf("%d",&a[i][j]);
//构造前缀和数组
for( int i = 1; i<=n; i++ )
for( int j = 1; j<=m; j++ )
s[i][j] = s[i-1][j] + s[i][j-1] - s[i-1][j-1] + a[i][j];
// q 次处理
while(q--)
{
int x1, x2, y1, y2, sum;
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
sum = s[x2][y2] - s[x1-1][y2] - s[x2][y1-1] + s[x1-1][y1-1];
printf("%d\n",sum);
}4.2 差分
用途：给区间加上相同值
一维差分
代码如下：
//差分处理
void insert( int l, int r, int c)
{
b[l] += c;
b[r+1] -= c;
}
//输入原数组
for( int i = 1; i <= n; i ++ )
scanf("%d",&a[i]);
//构造差分数组，再[i,i]q区间上插入a[i];
for( int i = 1; i <= n; i ++ )
insert(i,i,a[i]);
// q 次处理，再[l,r]区间上插入c;
while( q -- )
{
int l, r, c;
cin >> l >> r >> c ;
insert(l,r,c);
}二维差分
代码如下：
//二维数组的插入
void insert(int x1, int y1, int x2, int y2, int c)
{
S[x1][y1] += c;
S[x1][y2+1] -= c;
S[x2+1][y1] -= c;
S[x2+1][y2+1] += c;
}
//输入原数组
for( int i = 1; i <= n; i++ )
for( int j =1; j <= m; j++ )
scanf("%d",&A[i][j]);
//构造差分数组，在[i,j]到[i,j]上插入a[i];
for( int i = 1; i <= n; i++ )
for( int j =1; j <= m; j++ )
insert(i,j,i,j,A[i][j]);
// q 次插入，在[x1,y1]到[x2,y2]上插入c;
while( q -- )
{
int x1,y1,x2,y2,c;
cin >> x1 >> y1 >> x2 >> y2 >> c;
insert (x1,y1,x2,y2,c);
}
//前缀和公式将差分还原成 q 次操作后的数组
for( int i = 1; i <= n; i++ )
{
for( int j =1; j <= m; j++ )
{
S[i][j] += S[i-1][j] + S[i][j-1] - S[i-1][j-1];
printf("%d ",S[i][j]);
}
cout << endl;
}
5 双指针算法
常见问题分类：
(1) 对于一个序列，用两个指针维护一段区间
(2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作
代码如下：
for (int i = 0, j = 0; i < n; i ++ )
{
while (j < i && check(i, j)) j ++ ;
// 具体问题的逻辑
}6 位运算
常见问题分类：
（1）求n的第k位数字: n >> k & 1
（2）返回n的最后一位1：lowbit(n) = n & -n
代码如下：
//求n的第k位数字:
int find(int n,int k)
{
return n >> k & 1;
}
//lowbit操作，返回最后一位1；
int lowbit(int &x)
{
return x&(-x);
}
//lowbit用法举例
//统计x 的二进制表示数中有多少个1;
int main()
{
cin >> x;
while(x) x-=lowbit(x),res++;
cout << res << ' ' ;
}
7 离散化
常见问题：
区间长度很长，但数据非常稀疏；
代码如下：
// 存储所有待离散化的值
vector 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
} 8 区间合并
代码如下：
typedef pair PII;
// 将所有存在交集的区间合并
void merge(vector &segs)
{
vector res;
sort(segs.begin(), segs.end());
int st = -2e9, ed = -2e9;//定义一个最小区间边界-2e9（当区间边界为-1e9)
for (auto seg : segs)
if (ed < seg.first)
{
if (st != -2e9) res.push_back({st, ed});
st = seg.first, ed = seg.second;
}
else ed = max(ed, seg.second);
if (st != -2e9) res.push_back({st, ed});//处理最后一组数据
segs = res;
}
第二章 数据结构
C++ stl 库里包含以下数据结构，以下内容为用数组模拟构建
1 链表
常见操作：
<1> head(链表头）后插入数
<2> 在链表中任意一元素后插入数
<3> 删除 任意元素 后的数
1.1 单链表
代码如下：
// head存储链表头，e[]存储节点的值，ne[]存储节点的next指针，idx表示当前用到了哪个节点
int head, e[N], ne[N], idx;
//单链表初始化
void init()
{
head = -1;
idx=0;
}
//将x插入到头节点，即，将x插入到head的后面
//头节点为 head 后的数
void add_to_head(int x )
{
e[idx] = x;
ne[idx] = head;
head = idx++;
}
//将x插入到下标是 k 的点的后面
void add(int k, int x)
{
e[idx] = x;
ne[idx] = ne[k];
ne[k] = idx;
idx++;
}
//删除下标是k的点的后一位
void remove(int k)
{
ne[k] = ne[ne[k]];
}1.2 双链表
注：
插入操作的小技巧：在 a 前插入可化为，在 l[a] （ a 的左元素）后插入一个数；
代码如下：
// e[]表示节点的值，l[]表示节点的左指针，r[]表示节点的右指针，idx表示当前用到了哪个节点
int e[N], l[N], r[N], idx;
// 初始化
void init()
{
//0是左端点，1是右端点
r[0] = 1, l[1] = 0;
idx = 2;
}
// 在节点a的右边插入一个数x
void insert(int a, int x)
{
e[idx] = x;
l[idx] = a, r[idx] = r[a];
l[r[a]] = idx, r[a] = idx ++ ;
}
// 删除节点a
void remove(int a)
{
l[r[a]] = l[a];
r[l[a]] = r[a];
}
2 栈
常见操作：
<1> 栈顶插入一个数
<2> 栈顶弹出一个数
<3> 判断栈是非为空
<4> 查询栈顶的值
2.1 模拟栈
代码如下：
// tt表示栈顶
int stk[N], tt = 0;
// 向栈顶插入一个数
stk[ ++ tt] = x;
// 从栈顶弹出一个数
tt -- ;
// 栈顶的值
stk[tt];
// 判断栈是否为空
if (tt > 0)
{
}2.2 单调栈
常见模型：找出每个数左边离它最近的比它大/小的数
解题步骤：先暴力，在寻找永远用不到的数，将其删去；
代码如下：
int tt = 0;
for (int i = 1; i <= n; i ++ )
{
//向前比较，大于 x 就 pop 掉
while (tt && check(stk[tt], i)) tt -- ;
//将新数据读入栈
stk[ ++ tt] = i;
}3 队列
常见操作：
<1> 队尾插入一个书
<2> 队头弹出一个数
<3> 判断队列是否为空
<4> 查询队头元素
3.1 模拟普通队列
代码如下：
// hh 表示队头，tt表示队尾
int q[N], hh = 0, tt = -1;
// 向队尾插入一个数
q[ ++ tt] = x;
// 从队头弹出一个数
hh ++ ;
// 队头的值
q[hh];
// 判断队列是否为空
if (hh <= tt)
{
}3.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];
// 判断队列是否为空
if (hh != tt)
{
}3.3 单调队列
常见模型：找出滑动窗口中的最大值/最小值
//滑动窗口例题
int hh=0, tt=-1;
for(int i=0; iq[hh]) hh++;
//当队列不为空时，若队尾元素大于要入队的元素，证明 tt 元素没用，删除
while(hh<=tt && a[q[tt]] > a[i]) tt--;
//入队一个元素
q[++tt] = i;
if(i >= k-1) printf("%d ",a[q[hh]]);
} 4 KMP
简介：在KMP算法中，为了确定在匹配不成功时，下次匹配时j的位置，引入了next[]数组，next[j]的值表示P[0...j-1]中最长后缀的长度等于相同字符序列的前缀。
作用：字符串匹配
技巧：当匹配失败时，下一次从 next[j] 开始匹配，将时间复杂度由O(m*n)下降到O(m+n)
代码如下：
// s[]是长文本，p[]是模式串，n是p的长度，m是s的长度
const int N = 100010, M=1000010;
int n, m;
int ne[N];
char p[N], s[M];
// 求模式串的Next数组：
// 对 i=2 的解释：ne[i] = 0，所以从 ne[2] 开始求 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;
}
// kmp 匹配
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];
// 匹配成功后的逻辑
}
}
5 Trie树
简介：Trie树是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。
作用：高效地储存字符串 ，并快速查找
技巧：树状结构
代码如下：
int son[N][26], cnt[N], idx;
// 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];
}
6 并查集
简介：并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题
作用：并，合并；查，查找
技巧：p[x] = x 时为祖宗节点
6.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所在的两个集合：
p[find(a)] = find(b);6.2 维护size的并查集
代码如下：
//p[]存储每个点的祖宗节点, size[]只有祖宗节点的有意义，表示祖宗节点所在集合中的点的数量
int p[N], size[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;
size[i] = 1;
}
// 合并a和b所在的两个集合：
size[find(b)] += size[find(a)];
p[find(a)] = find(b);
6.3 维护到祖宗节点距离的并查集
代码如下：
int p[N], d[N];
//p[]存储每个点的祖宗节点, d[x]存储x到p[x]的距离
// 返回x的祖宗节点
int find(int x)
{
if (p[x] != x)
{
// 引入 t 变量，保存 p[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);
d[find(a)] = distance; // 根据具体问题，初始化find(a)的偏移量7 堆
堆：是一个完全二叉树，可用一维数组存储；
此为小根堆，堆顶为最小值；
代码如下：
// 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)
{
// 交换的是此处的值，t 与 u 不交换，t 仍然是 u*2 或 u*2+1
heap_swap(u, t);
down(t); // 继续down数组下标
}
}
void up(int u)
{
while (u / 2 && h[u] < h[u / 2])
{
heap_swap(u, u / 2);
u >>= 1; // 移位运算，等效于 u /= 2;
}
}
// O(n)建堆
// 从第二层开始建上半部分 n/2 , 下半部分 n/2, 时间复杂度O(n)
for (int i = n / 2; i; i -- ) down(i);
8 哈希表（hash表)
8.1 一般哈希（数字）
代码如下：
(1) 拉链法
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;
}
(2) 开放寻址法
int h[N];
// 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回x应该插入的位置
int find(int x)
{
int t = (x % N + N) % N;
while (h[t] != null && h[t] != x)
{
t ++ ;
if (t == N) t = 0;
}
return t;
}
8.2 字符串哈希
核心思想：将字符串看成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
// 初始化
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];
}
第三章 图论
1 DFS（深度优先搜索）
注意：DFS 无固定模板，两要素，循环退出条件，恢复现场；
代码例子如下：
1 2 3 的全排列
void dfs(int u)
{
if(u==n)
{
for(int i=0; i2 BFS （宽度优先遍历）
注意：有模板
模板思路：队列，第一个元素入队，队列不空，判断，符合则入队
代码如下：（迷宫最短路（权重为1））
int bfs()
{
queue q;
q.push({0, 0});
//初始化为 -1
memset(d,-1,sizeof d);
//建立坐标系 (dx[i],dy[i])表示向不同的方向拓展
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
//(0,0) 已经被拓展
d[0][0] = 0;
while(q.size())
{
//出队一个
auto t = q.front();
q.pop();
//四个方向判断
for(int i=0; i<4; i++ )
{
int x = t.first + dx[i], y = t.second + dy[i];
if(x >= 0 && x < n && y >=0 && y < m && g[x][y]==0 && d[x][y]==-1)
{
d[x][y] = d[t.first][t.second] + 1;// 可以走，路线长度 +1
q.push({x, y});// 入队一个
}
}
}
return d[n-1][m-1]; // 返回到终点时的长度
} 3 树和图的存储与遍历
3.1 存储
方法：1，稀疏图：邻接表（e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++ ; )
2，稠密图：邻接矩阵（g[a][b] = c ; )
代码如下：
// 邻接表
// 对于每个点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);
// 邻接矩阵
g[a][b] // 存储边a->b
3.2 遍历
时间复杂度 ：O(n+m), n 表示点数，m 表示边数
方法：1. 深度优先遍历 DFS
2. 宽度优先遍历 BFS
// 深度优先遍历 DFS
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);
}
}
// 宽度优先遍历 BFS
queue 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);
}
}
} 4 拓扑排序
邻接表存储
时间复杂度 O(n+m)， n 表示点数，m 表示边数
思想：队列，先存入度为零的点，遍历该点的下一个点，这个点入度减一，判断是否为零，为零则入队，若所有元素都入队，则存在拓扑排序
代码如下：
bool topsort()
{
int hh = 0, tt = -1;
// d[i] 存储点i的入度
for (int i = 1; i <= n; i ++ )
if (!d[i])
q[ ++ tt] = i;
while (hh <= tt)
{
int t = q[hh ++ ];
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (-- d[j] == 0)
q[ ++ tt] = j;
}
}
// 如果所有点都入队了，说明存在拓扑序列；否则不存在拓扑序列。
return tt == n - 1;
}
5 最短路
5.1 朴素 Dijkstra 算法
时间复杂度 O(n^2)
思路如下：1. 初始化,
2. 在还未确定最短路的点中, 寻找距离最小的点，
3. 用这个点更新其他路径
代码如下：
int g[N][N]; // 邻接矩阵，存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 先选中一个点，剩余 n - 1 个点，迭代 n - 1 次
for (int i = 0; i < n - 1; i ++ )
{
int t = -1; // 在还未确定最短路的点中，寻找距离最小的点
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
st[t] = true;
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
5.2 堆优化版 Dijkstra 算法
时间复杂度：O(mlogn)
思路：与朴素版相同，将第二步优化为弹出堆顶元素,更新堆时为logn
代码如下：
typedef pair 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, greater> heap;
heap.push({0, 1}); // first存储距离，second存储节点编号
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue; // 冗余备份，直接continue掉
st[ver] = true;
// 用 ver 来更新其他点的最短距离
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];
}
5.3 Bellman-Ford 算法
时间复杂度：O(nm)
思路：1. 题目要求最多 n 次，我们遍历 n 次；
2. 遍历所有边，共 m 条
代码如下：
int n, m; // n表示点数，m表示边数
int dist[N]; // dist[x]存储1到x的最短路距离
struct Edge // 边，a表示出点，b表示入点，w表示边的权重
{
int a, b, w;
}edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
// 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
// 只用当前这一步骤的最短路，防止串联
memcpy(last, dist, sizeof dist);
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
dist[b] = min(dist[b], last[a] + w);
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
5.4 SPFA 算法
（队列优化的Bellman-Ford算法）
时间复杂度 平均情况下 O(m)，最坏情况下 O(nm)
代码如下：
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue q;
q.push(1);
st[1] = true;
// 遍历所有边
while (q.size())
{
auto t = q.front();
q.pop();
// 及时改变为 false 可能重复入队
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];
if (!st[j]) // 如果队列中已存在j，则不需要将j重复插入
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
小知识：SPAF 算法判断负环
思路：在上述代码加上，所有点入队和记录经过的点的数组 cnt[n]，
代码如下：
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 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;
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
5.5 Floyd 算法
时间复杂度：O(n^3)
思路：起末位置中间插入一点，看距离是否最短
代码如下：
// 初始化：
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 ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
6 最小生成树
定义：在连通网的所有生成树中，所有边的代价和最小的生成树，称为最小生成树。
6.1 朴素 prim 算法
时间复杂度：O( n^2 + m )
思路：1. dist 初始化为正无穷
2. 循环 n 次
3. 找到 t ，更新点，到集合的距离
代码如下：
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;
}
6.2 堆优化版 prim 算法
此算法，不常用，略
6.3 Kruskal算法
时间复杂度：O(mlogm)
思路：1. 将所有边按权重从小到大排序
2. 枚举每条边 a, b, 权重 c
if a,b 不连通，将这条边加入集合
代码如下：
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;
}
7 二分图
定义：把一个图的顶点划分为两个不相交子集 ，使得每一条边都分别连接两个集合中的顶点。如果存在这样的划分，则此图为一个二分图。
7.1 染色法
时间复杂度：O(n + m)
思路：邻接表存储，dfs一遍，没染色，则染上色
代码如下：
int n; // n表示点数
int h[N], e[M], ne[M], idx; // 邻接表存储图
int color[N]; // 表示每个点的颜色，0表示未染色，1表示白色，2表示黑色
// 参数：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, 3 - c)) return false;
}
else if (color[j] == c) return false;
}
return true;
}
bool check()
{
memset(color, -1, sizeof color);
bool flag = true;
for (int i = 1; i <= n; i ++ )
if (!color[i])
if (!dfs(i, 1))
{
flag = false;
break;
}
return flag;
}
7.2 匈牙利算法
时间复杂度：O(mn)
作用：求二分图最大匹配数目
思路：枚举一边，如果重复，看上一个能不能换
代码如下：
int n1, n2; // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx; // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
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])
{
st[j] = true;
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 ++ ;
}
第四章 数学
1 质数
1.1 试除法判定质数
模板如下：
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;
}1.2 分解质因数
模板如下：
void divide(int x)
{
for(int i = 2; i <= x/i; i ++ )
{
if(x % i == 0)
{
int s=0;
while(x % i == 0) x /= i, s ++ ;
printf("%d %d\n", i, s);
}
}
if( x > 1 ) printf("%d %d\n", x, 1);
puts("");
}1.3 筛质数（线性筛）
线性筛例题：F. Function
例题讲解：F. Function 线性筛模板讲解
// 用每个合数的最小质因子筛去该数
void get_primes(int n)
{
for(int i = 2; i <= n; i ++ )
{
if(!st[i]) primes[cnt++] = i;
// 等同于 for(int j = 0; i * primes[j] <= n; j ++ )
// i * primes[j] 为 要筛的合数
for(int j = 0; primes[j] <= n/i; j ++ )
{
// 本次循环的作用筛去 合数primes[j] * i
// 两种情况，分别保证 i*primes[j] 被其最小质因子筛去
// 1、当 i % primes[j] != 0 时，primes[j] 一定小于i的任何质因子，所以，primes[j] 一定为 i*primes[j]的最小质因子时
// 2、当 i % primes[j] == 0 时，primes[j] 为i的最小质因子，同时也为i*primes[j]的最小质因子
st[primes[j] * i] = true;
// 当prmies[j] 为 i 的最小质因子时，结束，再继续就不能保证是被最小质因子筛去
if(i % primes[j] == 0) break;
}
}
}2 约数
2.1 试除法求约数
vector get_divisors(int x)
{
vector res; // 所有约数存于res数组中
for(int i = 1; i <= x/i; i ++ )
{
if( x % i == 0 )
{
res.push_back(i);
// 判断是否重复放入res中，也可以不分青红皂白都放入，然后再unique一下
if( i != x/i ) res.push_back(x/i);
}
}
sort(res.begin(), res.end());
return res;
} 2.2 约数个数
假设 数 n 可分解为：p1^a1 * p2 ^ a2 * …… * pk ^ ak（pk 为 n 的所有质数）
则 n 的约数个数为 (a1 + 1) * (a2 + 1) * …… * （ak + 1)
证明：设 n 的约数 x = p1 ^b1 * p2^b2 * …… * pk ^ bk，其中 0 <= bk <= ak，即对于每个ak，有 1+ak 种选择，所以所有个数为所有的 ak + 1 的乘积；
int main()
{
scanf("%d",&n);
unordered_map primes;
while(n -- )
{
int x;
scanf("%d",&x);
for(int i = 2; i <= x/i; i ++ )
{
while( x % i == 0)
{
x /= i;
primes[i] ++;
}
}
if(x > 1) primes[x] ++;
}
LL res = 1;
for(auto p : primes) res = res*(p.second+1)%mod;
cout << res << endl;
return 0;
} 2.3 约数之和
假设 数 n 可分解为：p1^a1 * p2 ^ a2 * …… * pk ^ ak（pk 为 n 的所有质数）
则 n 的约数之和为 (p1^0 + p1^1 + p1^2 + …… + p1^a1) * (p2^0 + p2^1 + p2^2 + …… + p2^a2) * …… * (pk^0 + pk^1 + pk^2 + …… + pk^ak)
证明：将上式用乘法分配律展开，即为所有的约数
int main()
{
int n;
cin >> n;
unordered_map primes;
while(n -- )
{
int x;
scanf("%d",&x);
for(int i = 2; i <= x / i; i ++ )
{
while(x % i == 0)
{
x /= i;
primes[i] ++;
}
if(x > 1) primes[x] ++;
}
}
LL res;
for(auto prime:primes)
{
int a = prime.first, b = prime.second;
LL t = 1;
while(b -- ) t = (t * a + 1)%mod;
res = res * t % mod;
}
cout << res << endl;
return 0;
} 2.4 最大公约数
欧几里得算法（辗转相除法）（与 C++ 的 __gcd(a,b) 一样）
int gcd(int a, int b)
{
return b?gcd(b, a%b):a;
}3 欧拉函数
3.1 求欧拉函数
欧拉函数：
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);
printf("%d\n", res);3.2 筛法求欧拉函数
方法：在线性筛种，根据 primes[j] 的两种情况，更新对应的 i * primes[j] 的欧拉函数
当 i % primes[j] == 0 时，i * primes[j] 的质因数与 primes[j] 的质因数一致，只更新 N 即可，即，将 ph[i * primes[j] ] = phi[i] * primes[j]
当i % primes[j] != 0 时，i * primes[j] 的质因数 比 primes[j] 多一个 primes[j] 本身，phi[i * primes[j] ] = phi[i] * (primes[j] - 1)/ primes[j] * primes[j] --> phi[i * primes] = phi[i] * (primes[j] - 1)
LL get_eulers(int n)
{
phi[1] = 1;
for(int i = 2; i <= n; i ++ )
{
if(!st[i])
{
primes[cnt++] = i;
phi[i] = i - 1;
}
for(int j = 0; primes[j] <= n / i; j ++ )
{
st[primes[j] * i] = true;
if(i % primes[j] == 0)
{
phi[primes[j] * i] = phi[i] * primes[j];
break;
}
phi[primes[j] * i] = phi[i] * (primes[j] - 1);
}
}
for(int i = 1; i <= n; i ++ ) res += phi[i];
return res;
}4 快速幂
4.1 求快速幂
LL qmi(int a, int k, int p)
{
LL res = 1;
while( k )
{
if(k & 1) res = (LL)res * a % p;
k >>= 1;
a = (LL)a * a % p;
}
return res;
}4.2 快速幂求逆元
一般即求 qmi(a, p-2, p)
逆元用到的场景：除法后模p，可转化为乘以乘法逆元后取余再模p（粗体部分再模p状态下等效）
#include
using namespace std;
typedef long long LL;
int n;
int qmi(int a, int k, int p)
{
int res = 1;
while(k)
{
// k & 1 返回二进制的最后一位的数字，
if( k & 1 ) res = (LL)res*a % p;
// 向右移 1 位，除去二进制的最后一位数字
k >>= 1;
// 算一位，a 乘 一倍
a = (LL)a*a % p;
}
return res;
}
int main()
{
scanf("%d",&n);
while(n -- )
{
int a, p;
scanf("%d%d",&a,&p);
int res = qmi(a, p-2, p);
if(a % p) printf("%d\n",res);
else puts("impossible");
}
return 0;
} 5 扩展欧几里得算法
5.1 扩展欧几里得算法
用途：证明裴蜀定理，并求出任意一组解
int exgcd(int a, int b, int &x, int &y)
{
// 到达递归边界，开始回溯
if(!b)
{
// 将(a, b)的系数，更新为(a, 0)的系数，推导出x = 1, y = 0，一定成立
x = 1, y = 0;
return a;
}
int d = exgcd(b, a%b, y, x);
// 将(a,b)的系数，更新为(b,a%b)的系数
y -= a/b*x;
return d; // 得到最大公因数
}5.2 线性同余方程
可化简为 a*x + m*y = b
其中，当 b 为 gcd(a, m) 的倍数时（即、gcd(a, m) | b），方程有解；反之，无解；
#include
using namespace std;
typedef long long LL;
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);
// 将(a,b)的系数，更新为(b,a%b)的系数
y -= a/b*x;
return d; // 得到最大公因数
}
int main()
{
int n;
scanf("%d",&n);
while(n -- )
{
int a, b, m, x, y;
scanf("%d%d%d",&a,&b,&m);
int d = exgcd(a,m,x,y);
if(b % d) puts("impossible");
else printf("%d\n",(LL) x * (b / d) % m );
}
return 0;
} 6 中国剩余定理
7 高斯消元
7.1 高斯消元解方程组
运用矩阵性质，变换，答案为 a[i][n]
步骤：变为行阶梯型
1、由第一列 c 开始向后枚举，找到本列的最大数的行
2、将最大行交换到为处理过的数据的第一行 r
3、将未处理数据第一行 r 除以第一个数，即、将首数据变为1
4、用本列的第一行行将下面未处理数据的本列其他数据消为0
判断，无解，无穷解，有解
若有解，倒着枚举每行的数据，a[i][n] 即为所求结果
#include
#include
#include
#include
using namespace std;
const int N = 110;
const double eps = 1e-8;
int n;
double a[N][N];
int gauss() // 高斯消元，答案存于a[i][n]中，( i >= 0 && i < n )
{
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[r][i], a[t][i]);
// 将当前行的首位变成1
for(int i = n; i >= c; i -- )
a[r][i] /= a[r][c];
// 再该列上，用当前行的数将下面所有的行的数消成0
for(int i = r + 1; i < n; i ++ )
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)
{
// 无解，0x = 实数
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; // 有唯一解
}
int main()
{
scanf("%d", &n);
for (int i = 0; i < n; i ++ )
for (int j = 0; j < n + 1; j ++ )
scanf("%lf", &a[i][j]);
int t = gauss();
if (t == 2) puts("No solution");
else if (t == 1) puts("Infinite group solutions");
else
{
for (int i = 0; i < n; i ++ )
{
if (fabs(a[i][n]) < eps) a[i][n] = 0; // 去掉输出 -0.00 的情况
printf("%.2lf\n", a[i][n]);
}
}
return 0;
}
7.2 高斯消元解异或线性方程组
异或：不进位加法，和普通高斯消元类似，将 +，- 换成 ^
#include
using namespace std;
const int N = 110;
int n;
int a[N][N];
int gauss()
{
int r, c;
for(r = c = 0; c < n; c ++ )
{
int t = r;
for(int i = r; i < n; i ++ )
if(a[i][c])
{
t = i;
break;
}
if(!a[t][c]) continue;
for(int i = c; i <= n; i ++ )
swap(a[t][i], a[r][i]);
for(int i = r + 1; i < n; i ++ )
if(a[i][c])
for(int j = c; j <= n; j ++ )
a[i][j] ^= a[r][j];
r ++;
}
if(r < n)
{
for(int i = r; i < n; i ++ )
if(a[i][n])
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;
}
int main()
{
scanf("%d", &n);
for(int i = 0; i < n; i ++ )
for(int j = 0; j < n + 1; j ++ )
scanf("%d", &a[i][j]);
int t = gauss();
if(t == 2) puts("No solution");
else if(t == 1) puts("Multiple sets of solutions");
else
{
for(int i = 0; i < n; i ++ )
printf("%d\n", a[i][n]);
}
return 0;
} 8 求组合数
8.1 组合数 I
方法：预处理 + 递推
时间复杂度：O( n^2 )
#include
#include
using namespace std;
const int N = 2010, mod = 1e9+7;
int c[N][N];
void init()
{
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-1] + c[i-1][j]) % mod;
}
}
}
int main()
{
init();
int n;
scanf("%d",&n);
while( n -- )
{
int a, b;
scanf("%d%d",&a, &b);
printf("%d\n",c[a][b]);
}
return 0;
} 8.2 组合数 II
方法：预处理阶乘 + 求逆元
时间复杂度：O( nlogn )
#include
#include
using namespace std;
typedef long long LL;
const int N = 100010, mod = 1e9+7;
int fact[N], infact[N];
int qmi(int a, int k, int p)
{
int res = 1;
while(k)
{
if(k & 1) res = (LL)res * a % p;
k >>= 1;
a = (LL) a * a % p;
}
return res;
}
int main()
{
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) % mod;
}
int n;
scanf("%d",&n);
while(n -- )
{
int a, b;
scanf("%d%d",&a,&b);
int res = (LL)fact[a] * (infact[a-b] % mod) * (infact[b] % mod) % mod;
printf("%d\n",res);
}
return 0;
} 8.3 组合数 III
理论基础：Lucas定理（卢卡斯定理）
方法：Lucas定理 + 基础组合数求法 + 逆元
时间复杂度：
化简为
#include
#include
using namespace std;
typedef long long LL;
int p;
int qmi(int a, int k)
{
int res = 1;
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 res = 1;
for(int i = 1, j = a; i <= b; i ++, j -- )
{
res = (LL)res * j % p;
res = (LL)res * qmi(i, p - 2) % p;
}
return res;
}
int lucas(LL a, LL b)
{
if(a < p && b < p ) return C(a, b);
else return (LL)C(a % p, b % p) * lucas(a / p, b / p ) % p ;
}
int main()
{
int n;
cin >> n;
while(n -- )
{
LL a, b;
cin >> a >> b >> p ;
int res = lucas(a, b);
cout << res << endl;
}
return 0;
} 8.4 组合数 IV
方法：分解质因数 + 阶乘求质因数 + 高精度乘法
#include
#include
#include
using namespace std;
const int N = 5010;
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; // 注意 == 0
}
}
}
int get(int n, int p)
{
int res = 0;
while(n)
{
res += n / p;
n /= p;
}
return res;
}
vector mul(vector a, int b)
{
vector res;
int t = 0;
for(int i = 0; i < a.size() || t ; i ++ )
{
if(i < a.size()) t += a[i] * b;
res.push_back(t % 10);
t /= 10;
}
while(a.size() > 0 && a.back() == 0) a.pop_back();
return res;
}
int main()
{
int a, b;
cin >> a >> b ;
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 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]);
}
}
for(int i = res.size() - 1; i >= 0; i -- )
{
printf("%d",res[i]);
}
puts("");
return 0;
}
8.5 卡特兰数
点击跳转：卡特兰数 ，
具体公式如下所示：
推导过程如下：
例题：889. 满足条件的01序列
AC代码：
#include // 卡特兰数
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
int qmi(int a, int k, int p)
{
int res = 1;
while(k)
{
if(k & 1) res = (LL)res * a % mod;
a = (LL) a * a % mod;
k >>= 1;
}
return res;
}
int main()
{
int n;
cin >> n ;
int a = 2 * n, b = n, res = 1;
for(int i = a; i > a - b; i -- ) res = (LL)res * i % mod;
for(int i = 1; i <= b; i ++ ) res = (LL)res * qmi(i, mod - 2, mod) % mod;
res = (LL)res * qmi(n+1, mod-2, mod) % mod;
cout << res << endl;
return 0;
} 9 容斥原理
点此处跳转：容斥原理
方法：容斥原理 + 位运算枚举所有状态
例题：能被整除的数
AC代码：
#include
#include
using namespace std;
typedef long long LL;
const int N = 20;
int n, m;
int p[N];
int main()
{
cin >> n >> m ;
int res = 0;
for(int i = 0; i < m; i ++ ) cin >> p[i];
for(int i = 1; i < 1 << m; i ++ )
{
int t = 1, cnt = 0;
for(int j = 0; j < m; j ++ )
{
if(i >> j & 1)
{
cnt ++ ;
if((LL)t * p[j] > n)
{
t = -1;
break;
}
t *= p[j];
}
}
if( t != -1 )
{
if(cnt % 2) res += n / t;
else res -= n / t;
}
}
cout << res << endl;
return 0;
} 10 博弈论
10.1 Nim游戏
例题链接：Nim游戏
必胜态与必败态：
先手必胜态：可以走到任意一个必败态
先手必败态：无法走到任意一个必败态
明确三点：
1. 0 ^ 0 ^ 0 ^ …… ^ 0 = 0 (必败态）
2. a[1] ^ a[2] ^ a[3] ^ …… ^ a[n] = x != 0（必胜态）
3. a[1] ^ a[2] ^ a[3] ^ …… ^ a[n] = 0（必败态）
证明以上三点：
1. 不用证明
2.知：a[i] ^ x <= a[i]， 我们可以大于 x 的 a[i] 中取走 a[i] - (a[i] ^ x) 个物品，使 a[i] -> a[i] ^ x，如此，即、a[1] ^ a[2] ^ a[3] ^ …… ^ a[n]^x = x^x = 0，另一个人再取任意物品都会使 异或值 不等于 0 ，我们再使结果为0，如此，后者所在的状态都是异或值为0的状态，所以 条件1 的必败态一定归后手
3. 取任意物品，都会破坏异或0的状态，从而使对方取后自己取时仍未异或0的状态，即必败态归先手
所以只需判断，所有的物品异或一起的值是否未0，=0 (必败态），!= 0 (必胜态）
代码如下
#include
#include
using namespace std;
int main()
{
int n;
cin >> n;
int res = 0;
while(n -- )
{
int x;
scanf("%d",&x);
res ^= x;
}
if(res) puts("Yes");
else puts("No");
return 0;
} 10.2 台阶-Nim游戏
例题链接：台阶-Nim游戏
明确三点：
1. 0 ^ 0 ^ 0 ^ …… ^ 0 = 0 (必败态）
2. a[1] ^ a[3] ^ a[5] ^ …… ^ a[2*n-1] = x != 0（必胜态）
3. a[1] ^ a[3] ^ a[5] ^ …… ^ a[2*n-1] = 0（必败态）
证明：
若移动偶数项，则另一个人移动偶数项的下面一项（即前一项），是奇数项数不变，如此可知，答案于偶数项无关。
若移动奇数项，则可将必胜态于必败态互换，另一人再是必胜态必败态互换，则相当于状态没变，所以胜负再输入数据的那一刻就已经分出分晓
代码如下：
#include
using namespace std;
int main()
{
int n, x, res = 0;
scanf("%d", &n);
for(int i = 1; i <= n; i ++ )
{
scanf("%d", &x);
if(i % 2) res ^= x;
}
if(res) puts("Yes");
else puts("No");
return 0;
} 10.3 集合-Nim游戏
例题链接：集合-Nim游戏
mex函数与SG函数：
思路：将所有堆石子的SG函数异或起来，若为 0 则先手必败，反之先手必胜
SG(x) = x != 0，可以走到任意的小于 x 的 SG(x - t) 函数，同时保证对手只能走到 0 ，必败态。
SG(x) == 0，终点，为必败态。
令所有的石子堆异或为 0 ，即为 先手必败态
求SG函数：记忆化搜索
代码如下：
#include
using namespace std;
const int N = 110, M = 10010;
int n, m;
int s[N], f[M];
int sg(int x)
{
if(f[x] != -1) return f[x];
unordered_set S;
for(int i = 0; i < m; i ++ )
{
int sum = s[i];
if(x >= sum) S.insert(sg(x - sum));
}
for(int i = 0; ; i ++ )
if(!S.count(i))
return f[x] = i;
}
int main()
{
scanf("%d", &m);
for(int i = 0; i < m; i ++ ) scanf("%d", &s[i]);
memset(f, -1, sizeof f);
scanf("%d", &n);
int res = 0, x;
for(int i = 0; i < n; i ++ )
{
scanf("%d", &x);
res ^= sg(x);
}
if(res) puts("Yes");
else puts("No");
return 0;
} 10.4 拆分-Nim游戏
例题链接：拆分-Nim游戏
与集合Nim相似，后继状态为最大值小于当前状态 x 的所有二元组（i，j）
即sg(x) = mex{sg(i) ^ sg(j)……};
代码如下：
#include
using namespace std;
const int N = 110;
int n;
int f[N];
int sg(int x)
{
if(f[x] != -1) return f[x];
unordered_set S;
for(int i = 0; i < x; i ++ )
for(int j = 0; j <= i; j ++ )
S.insert(sg(i) ^ sg(j));
for(int i = 0; ; i ++ )
if(!S.count(i))
return f[x] = i;
}
int main()
{
scanf("%d", &n);
memset(f, -1, sizeof f);
int res = 0, x;
for(int i = 0; i < n; i ++ )
{
scanf("%d", &x);
res ^= sg(x);
}
if(res) puts("Yes");
else puts("No");
return 0;
} 第五章 动态规划
1 背包问题
背包九讲（闫氏DP分析法）（详细思路及证明）
2 线性DP
线性DP模板题
3 区间DP
区间DP模板题（石子合并）
4 计数类DP
计数类DP模板题（900. 整数划分）
5 数位统计DP
数位统计DP（338. 计数问题）
6 状态压缩DP
状态压缩DP（蒙德里安的梦想，最短Hamilton路径）
7 树形DP
树形DP（没有上司的舞会）
8 记忆化搜索
记忆化搜索（滑雪）