acwing算法基础课-第一章 基础算法
基础算法
- 快速排序
-
- 思想
- 模板
- 注意点
- AcWing 785. 快速排序（模板题）
- AcWing 786. 第k个数
- 归并排序
-
- 思想
- 模板
- AcWing 787 . 归并排序（模板题）
- AcWing 788 . 逆序对的数量
- 二分
-
- 思路
- 模板
- AcWing 789 . 数的范围（模板题）
- AcWing 790 . 数的三次方根（模板题）
- 高精度
-
- 思想
- 高精度加法模板
- AcWing 791 高精度加法（模板题）
- 高精度减法模板
- AcWing 792 高精度减法（模板题）
- 高精度乘低精度模板
- AcWing 793 高精度乘法（模板题）
- 高精度除以低精度模板
- AcWing 794 高精度除法（模板题）
- 前缀和与差分
-
- 一维前缀和模板
- Acwing 795 前缀和 （模板题）
- 二维前缀和模板
- Acwing 796 子矩阵的和（模板题）
- 一维差分模板
- Acwing 797 差分（模板题）
- 二维差分模板
- Acwing 798 差分矩阵（模板题）
- 双指针算法
-
- 思想
- 模板
- AcWing 799 最长连续不重复子序列（模板题）
- AcWing 800 数组元素的目标和（模板题）
- AcWing 2816 判断子序列
- 位运算
-
- 模板
- AcWing 801 二进制中1的个数（模板题）
- 离散化
-
- 思想
- 模板
- 注意
- AcWing 802 区间和（模板题）
- 区间合并
-
- 模板
- AcWing 803 区间合并（模板题）
快速排序
思想
- 确定分界点
- 先调整区间（小的移左边，大的移右边）
- 再递归
模板
void quick_sort(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)
{
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);
}
注意点
注意边界问题：
递归时
如果 quick_sort(q, l, j) 与 quick_sort(q, j+1, r)
注意 x 不等于 q[ r ] 否则容易死循环,例 数组q为 0,1.死循环
同理，
如果 quick_sort(q, l, i-1) 与 quick_sort(q, i, r)
注意 x 不等于 q[ l ] 否则容易死循环,例 数组q为 0,1.死循环
AcWing 785. 快速排序（模板题）
#includeAcWing 786. 第k个数
//虽然可以全部求出后，直接得出答案，但我们可以优化一下 ，提高效率
//每次一分为二后， 只需管 k 所在的那一半即可（优化效率）
//重点是从小到大的第 k 个数 ，因此核心是数组第 k 个数的下标
//quick_sort（）的 k 代表当前数组的第 k 个位置，所以需要当前数组左侧长（右侧长 - 左侧长） 与其作比较
//如果当前数组左侧长大于等于 k ，quick_sort（）的 k 还是原来的 k，因为该次递归时，相对位置不变
//如果当前数组左侧长小于 k ，quick_sort（）的 k 为 k - len，因为该次递归时，相对位置变了
//最后即可得出 q[k]的值
#include归并排序
思想
- 确定分界点
- 先递归后再排序
- 归并
模板
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];
}
AcWing 787 . 归并排序（模板题）
#includeAcWing 788 . 逆序对的数量
//1. 暴力解法可以，但最坏情况，n*（n-1）大约为5*10e9
//2. 所以可以考虑归并
//3. 仔细思考归并算法的过程
//4. 在合并时，两个子序列为有序序列，再联系一下题目要求，有思路了
//5. q[i…mid]为有序序列，如果q[i]>q[j],那么q[i…mid]是不是都大于q[j],所以 num += mid - i + 1
#include二分
思路
分成满足某个性质及不满足该性质的两个区间，再用二分法找到区间边界的点
模板
整数模板
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;
else r = mid - 1;
}
return l;
}
浮点数二分算法模板
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;
}
AcWing 789 . 数的范围（模板题）
#includeAcWing 790 . 数的三次方根（模板题）
注意，一般要求保留 x 为小数时，计算时，精确到 1e - (x+2) ,即多两位，确保精确度。
#include高精度
基本概念：高精度算法（High Accuracy Algorithm）是处理大数字的数学计算方法。在一般的科学计算中，会经常算到小数点后几百位或者更多，当然也可能是几千亿几百亿的大数字。一般这类数字我们统称为高精度数，高精度算法是用计算机对于超大数据的一种模拟加，减，乘，除，乘方，阶乘，开方等运算。对于非常庞大的数字无法在计算机中正常存储，于是，将这个数字拆开，拆成一位一位的，或者是四位四位的存储到一个数组中， 用一个数组去表示一个数字，这样这个数字就被称为是高精度数。高精度算法就是能处理高精度数各种运算的算法，但又因其特殊性，故从普通数的算法中分离，自成一家。
思想
注意点：
- 考虑进位，如果正序存储，需每个元素都后移一位，所以我们采用逆序存储，一般题目会综合考察高精度加法，减法，乘法，除法，所以我们为了统一操作，都采用逆序存储。
- x - ‘0’ 表示字符类型转整数类型；x + ‘0’ 表示整数类型转字符类型。
高精度加法模板
// 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;
}
AcWing 791 高精度加法（模板题）
#include高精度减法模板
// 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;
}
AcWing 792 高精度减法（模板题）
#include高精度乘低精度模板
// 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;
}
AcWing 793 高精度乘法（模板题）
#include高精度除以低精度模板
// 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;
}
AcWing 794 高精度除法（模板题）
#include前缀和与差分
一维前缀和模板
S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]
Acwing 795 前缀和 （模板题）
#include二维前缀和模板
S[i, j] = 第i行j列格子左上部分所有元素的和
以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵的和为：
S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]
Acwing 796 子矩阵的和（模板题）
#include一维差分模板
数组的首元素为0，不用它，因为需用到 b[1] += b[0] .
给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c
Acwing 797 差分（模板题）
#include二维差分模板
数组的首元素为0，不用它，因为 b[1][1] 需用到 b[0][0] .
给以(x1, y1)为左上角，(x2, y2)为右下角的子矩阵中的所有元素加上c：
S[x1, y1] += c, S[x2 + 1, y1] -= c, S[x1, y2 + 1] -= c, S[x2 + 1, y2 + 1] += c
Acwing 798 差分矩阵（模板题）
#include 双指针算法
思想
核心：优化时间复杂度
特点：一般而言，两个指针单向移动，以便达到优化时间复杂度的目的
模板
//双指针算法 —— 模板题 AcWIng 799. 最长连续不重复子序列, AcWing 800. 数组元素的目标和
for (int i = 0, j = 0; i < n; i ++ )
{
while (j < i && check(i, j)) j ++ ;
// 具体问题的逻辑
}
常见问题分类：
(1) 对于一个序列，用两个指针维护一段区间
(2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作
AcWing 799 最长连续不重复子序列（模板题）
#includeAcWing 800 数组元素的目标和（模板题）
#includeAcWing 2816 判断子序列
#include位运算
模板
注：x 的负数等于 x 的补码，补码等于反码加一
位运算 —— 模板题 AcWing 801. 二进制中1的个数
求n的第k位（二进制）数字: n >> k & 1
返回n的最后一位1（二进制）：lowbit(n) = n & -n
AcWing 801 二进制中1的个数（模板题）
#include离散化
思想
离散化，把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。
通俗的说，离散化是在不改变数据相对大小的条件下，对数据进行相应的缩小。例如：
原数据：1,999,100000,15；处理后：1,3,4,2；
原数据：{100,200}，{20,50000}，{1,400}；
处理后：{3,4}，{2,6}，{1,5}；
模板
离散化 —— 模板题 AcWing 802. 区间和
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
}
注意
c11标准 可以用 for(auto item:a).
c98标准不允许 auto 及 for(auto item:a) 操作
//a 为 vectorAcWing 802 区间和（模板题）
vs2022 c11标准 展示
#includedevc++ c98标准展示
#include区间合并
模板
vs2022 c11标准 展示
模板是本区间与下一个区间存在空隙时，将本区间放入结果，所以最后一个区间也要加到结果里去。
区间合并 —— 模板题 AcWing 803. 区间合并
// 将所有存在交集的区间合并
void merge(vector<PII> &segs)
{
vector<PII> res;
sort(segs.begin(), segs.end());
int st = -2e9, ed = -2e9;
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;
}
AcWing 803 区间合并（模板题）
devc++ c98标准 展示
如果你的编译器是c11标准的，将我的merge函数换成模板中的merge函数就ok了
#include