提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
目录
前言
本人几乎无任何算法基础，最近想开始完整学一遍基础的算法
一、排序
1.快速排序
代码思想：每次都用数组中的某个数x来把数组分割成两部分使得左边部分小于x,右边部分大于x。(用两个指针来进行对比移动）
例题：输入N个数字，并将这些数字进行排序。输入：n代表数字个数，然后将n个数写入。输出：排好序的n个数。
代码如下（示例）：
#include<iostream>
using namespace std;
const int N =1e6 + 10;
int n;
int p[N];
void quick_sort(int p[], int l, int r){
if(l >= r) return;
int x = p[l+r>>1], i = l-1, j = r+1; //若x = p[r]则存在边界问题（对于后续递归参数）
while(i < j){
while(p[++i] < x);
while(p[--j] > x);
//swap(a[i], a[j]);
if(i < j){
int k = p[i];
p[i] = p[j];
p[j] = k;
}
}
// 采用递归
quick_sort(p, l, j);
quick_sort(p, j+1, r);
}
int main(){
scanf("%d",&n); //比cin读入快
for(int i = 0; i < n ; i++){
scanf("%d",&p[i]);
}
quick_sort(p, 0, n-1);
for(int i = 0; i < n ; i++){
cout<<p[i]<<" ";
}
}
代码要熟练运用，最好找几道题题目练手，注意边界问题，熟练运用此代码模板即可完美消除边界问题。
2.归并排序
代码思想：利用递归函数将数组左右对分后合并。此算法关键在于合并过程：利用一个临时数组将待合并的两串数字按大小顺序录入到临时数组，再将临时数组保存回原数组，反复操作。（用两个指针分别指向两个数组）
例题：输入N个数字，并将这些数字进行排序。输入：n代表数字个数，然后将n个数写入。输出：排好序的n个数。
代码如下（示例）：
#include<iostream>
using namespace std;
const int N =1e6 + 10;
int n;
int p[N], tmp[N]; //定义原数组和临时数组
void merge_sort(int p[], int l, int r){
if(l >= r)return;
int mid = (l + r)/2;
merge_sort(p, l, mid);
merge_sort(p, mid+1, r);
//合并过程
int k = 0, i = l, j = mid+1;
while(i <= mid && j <= r)
if(p[i] <= p[j]) tmp[k++] = p[i++];
else tmp[k++] = p[j++];
while(i <= mid) tmp[k++] = p[i++];
while(j <= r) tmp[k++] = p[j++];
for(i = l, j = 0; i <= r; i++, j++) p[i] = tmp[j];
}
int main(){
scanf("%d", &n);
for(int i = 0 ; i < n; i++){
scanf("%d", &p[i]);
}
merge_sort(p, 0, n-1);
for(int i = 0 ; i < n ;i++){
cout<<p[i]<<" ";
}
}将此段代码多默写几次，然后运行看结果 ，保证可以快速准确地盲打出相应代码。
上述两种排序代码可copy到此处 测试 来查看是否正确且有效。
二、二分查找
1.整数二分
代码思想：将数组区间一直二分（即分成两部分）且每次取带查找值存在的区间继续进行二分，直到最后分到一个数即为待查询数。整数二分边界问题有点麻烦，但只要明白如何分，然后将待分区间写出确定为是哪个模板，即可进行套用。
代码如下（示例）：
整数二分：
//模板1：区间[l, r]被划分为[l, mid]和[mid + 1, r]时使用 r = mid
int bsearch_1(int l, int r){
while(l < r){
int mid = l+r >> 1;
if(check(mid)) r = mid;
else l = mid + 1;
}
return 1;
}
//模板2： 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用 l = mid
int bsearch_2(int l, int r){
while(l < r){
int mid = l + r +1 >> 1; //此处与模板1不同
if(check(mid)) l = mid;
else r = mid - 1;
}
return 1;
}此模板代码需熟练记住，并且懂得通过分区方式来确定模板的选择。如果题设带查找值不存在，最后可能会二分到某处边界值（具体问题具体分析）
2.浮点数二分
代码思想：这个算法比较简单，没有边界问题。将一个范围进行不断瓜分（每次均取满足待查找值存在的区间），直到瓜分到区间长度很小（此时可取区间左右端点值）可认为找到答案。
代码如下（示例）：
#include<iostream>
using namespace std;
int main(){
double x;
cin >> x;
double l = 0, r = x;
while (r - l > 1e-6){ //为防止误差，可提高精度。经验：如何题目要求四位小数，此时精度设为1e-6;五位即1e-7，以此类推
double mid = (r + l)/2;
if(mid * mid > x ) r = mid;
else l = mid;
}
printf("%lf", l);
return 0;
}此代码模板较为简单，注意精度即可。
三、高精度算法
1.高进度加法
代码思想：利用vector（类似动态数组具体可参考 此 进行查看）存储数字，高位存在末尾（方便进位计算），然后通过加法运算规则来进行实现，较为简单。
代码如下（示例）：
#include<iostream>
#include<vector>
using namespace std;
const int N = 1e6 + 10;
vector<int> add(vector<int> &A, vector<int> &B){ //使用引用不会产生副本提高效率
vector<int> C;
int t = 0; //保存进位
for( int i = 0; i < A.size() || i < B.size() ; i++ ){
if( i < A.size() ) t += A[i];
if( i < B.size() ) t += B[i];
C.push_back(t % 10);
t /= 10;
}
if(t) C.push_back(1);
return C;
}
int main(){
string a, b;
vector<int> A, B;
cin >> a >> b;
for( int i = a.size() - 1; i >= 0; i-- ) A.push_back(a[i] - '0');
for( int i = b.size() - 1; i >= 0; i-- ) B.push_back(b[i] - '0');
auto C = add(A, B);
for( int i = C.size() - 1; i >= 0; i--) cout << C[i];
return 0;
}注：使用dev c++进行编译时auto可能会报错，原因：默认把auto当作声明自动声明周期的关键字(C++98标准)，而不是自动类型的关键字；在C++11标准中auto可以在声明变量的时候根据变量初始值的类型自动为此变量选择匹配的类型。解决措施：在工具中的编译选项中加入此语句即可
2.高精度减法
代码思想：此算法较加法难一些，也需要设定变量来记录进位，但与加法不同的是需要对两数的大小先进行判定，因为减法函数只适用于大减小，通过所以需要先通过判定数的大小调换位置来进行减法运算。
代码如下（示例）：
#include<iostream>
#include<vector>
using namespace std;
const int N = 1e6 + 10;
bool cmp(vector<int> &A, vector<int> &B){ //引用提高效率
if(A.size() != B.size()) return A.size() > B.size();
for(int i = A.size() - 1; i >= 0; i--){
if(A[i] != B[i]) return A[i] >= B[i];
}
return true;
}
vector<int> sub(vector<int> &A, vector<int> &B){
vector<int> C;
int t = 0;
for(int i = 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;
}
//消除前导 0
while(C.size() > 1 && C.back() == 0) C.pop_back();
return C;
}
int main(){
string a, b;
cin >> a >> b;
vector<int> A, B;
for(int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
for(int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');
if (cmp(A, B)){
auto C = sub(A, B);
for(int i = C.size() - 1; i >= 0; i--) cout << C[i];
}
else{
auto C = sub(B, A);
cout<<"-";
for(int i = C.size() - 1; i >= 0; i--) cout << C[i];
}
return 0;
}高精度减法较加法复杂，需要更多的去熟悉该算法模板。
3.高精度乘法
代码思想：算法与高精度加法类似，使用一个大整数去乘一个int型整数，与传统意义的乘法不同的是该算法用的是大整数的每一位去乘小整数整体，用一个变量来进行进位记录。注意要消除前导0即可。
代码如下（示例）：
#include<iostream>
#include<vector>
using namespace std;
const int N = 1e6 + 10;
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;
}
//消除前导0
while(C.size() > 1 && C.back() == 0) C.pop_back();
return C;
}
int main(){
string a;
vector<int> A;
int b;
cin >> a >> b;
for( int i = a.size() - 1; i >= 0; i-- ) A.push_back(a[i] - '0');
auto C = mul(A, b);
for( int i = C.size() - 1; i >= 0; i--) cout << C[i];
return 0;
}该算法与高精度加法类似熟练运用即可。
4.高精度除法
代码思想：与传统除法运算类似，但不同点在于需要一位位把被除数从高位开始每一位除以除数，设置商数组保存整除结果，余数乘以10加上下一位被除数重复此操作直到取到被除数最低位位置，但注意高精度里面高位一般存在最后所以在高精度除法运算结果后进行前后对调以符合习惯。注意最后消除前导0即可。
代码如下（示例）：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int N = 1e6 + 10;
//A/b, 商是C，余数是r
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 = r % b;
}
reverse(C.begin(), C.end()); //将大数组逆序过来以符合高位在末尾
//消除前导0
while(C.size() > 1 && C.back() == 0) C.pop_back();
return C;
}
int main(){
string a;
vector<int> A;
int b;
cin >> a >> b;
for( int i = a.size() - 1; i >= 0; i-- ) A.push_back(a[i] - '0');
int r;
auto C = div(A, b, r);
for( int i = C.size() - 1; i >= 0; i--) cout << C[i];
cout << endl << r;
return 0;
}理解除数算法思想，熟练模板和注意事项（逆序+消除前导0即可）。
四、前缀与差分算法
1. 前缀和（一维）
代码思想：此算法核心为某一段以l为左端r为右端的数组的和可以表达s[r] - s[l - 1]。对于不同的查询只要做好s[N]的初始化即可。
代码如下（模板）：
#include <iostream>
using namespace std;
int n, m;
const int N = 1e6 + 10;
int a[N], s[N];
int main(){
scanf("%d%d", &n, &m);
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]; // 前缀和的初始化
while(m--){
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", s[r] - s[l - 1]); // 区间和的计算
}
return 0;
}2.子矩阵的和
代码思想：和一维的前缀和思想类似，但二维前缀和的初始化以及子矩阵的计算方法用到容斥原理，该代码核心为两个公式：s[i][j] = s[i][j - 1] + s[i - 1][j] - s[i - 1][j - 1] + a[i][j] 、 s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1- 1][y1 - 1] 。
代码如下（模板）：
#include<iostream>
using namespace std;
int n , m, q;
const int N = 1e3 + 10; //太大会爆掉
int a[N][N], s[N][N];
int main(){
scanf("%d%d%d", &n, &m, &q);
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][j - 1] + s[i - 1][j] - s[i - 1][j - 1] + a[i][j];
while(q--){
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
// 算子矩阵的和
printf("%d\n", s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1- 1][y1 - 1]);
}
return 0;
}
该代码的核心即是容斥原理公式的运用，熟练代码模板即可轻松求出子矩阵的和。注：二维数组不能开太大
3. 差分（一维）
代码思想：此算法核心只需要操作差分数组从而作用于前缀和数组，对于前缀和数组A[n]来说对其中某段(l, r)加一个c可通过其差分数组B[n]中的B[l] + c 并且 B[r + 1] - c 来实现，利用此原理构造差分数组并且进行加减操作的应用。
代码如下（模板）：
#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int n, m;
int a[N], b[N];
//利用对差分数组的加减来实现前缀和数组的加减
void insert(int l, int r, int c){
b[l] += c;
b[r + 1] -= c;
}
int main(){
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; i ++) scanf("%d", &a[i]);
for(int i = 1; i <= n; i ++) insert(i, i, a[i]); //利用已有的a[N]数组来初始化b[N]
while(m--){
int l, r, c;
scanf("%d%d%d", &l, &r, &c);
insert(l, r, c);
}
// 利用累加来表示前缀和
for(int i = 1; i <= n; i ++ ) b[i] += b[i - 1];
for(int i = 1; i <= n; i ++ ) printf("%d ", b[i]);
return 0;
}4. 差分矩阵
代码思想： 与一维差分类似，核心思想与一维类似，不过在二维中会用到容斥原理对差分数组的操作且为B[x1][y1] += c; B[x2 + 1][y1] -= c;B[x1][y2 + 1] -= c;B[x2 + 1][y2 + 1] += c; 利用对差分数组的操作来实现对前缀和数组的操作。
代码如下（模板）：
#include <iostream>
using namespace std;
const int N = 1e3 + 10;
int n, m, q;
int a[N][N], b[N][N];
//对差分数组进行处理
void insert(int x1, int y1, int x2, int y2, int c){
b[x1][y1] += c;
b[x2 + 1][y1] -= c;
b[x1][y2 + 1] -= c;
b[x2 + 1][y2 + 1] += c;
}
int main(){
scanf("%d%d%d", &n, &m, &q);
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 ++ )
insert(i, j, i, j, a[i][j]);
while(q -- ){
int x1, y1, x2, y2, c;
scanf("%d%d%d%d%d", &x1, &y1, &x2, &y2, &c);
insert(x1, y1, x2, y2, c);
}
// 用差分数组来存储前缀和
for(int i = 1; i <= n; i ++ )
for(int j = 1; j <= m; j ++ )
b[i][j] += b[i][j - 1] + b[i - 1][j] -b[i - 1][j - 1];
for(int i = 1; i <= n; i ++ ){
for(int j = 1; j <= m; j ++ )
printf("%d ", b[i][j]);
cout << endl;
}
return 0;
}注意二维中容斥原理的运用，同时熟练二维模板方可运用。
五、双指针算法
代码思想：将原本朴素暴力算法中时间复杂度o(n^2)通过找规律优化算法降为可能的o(n)。
代码如下（模板）：
//攻克题目思路
//先想个双指针的朴素算法来确定
for(int i = 0; i < n; i ++ ){
for(int j = 0; j < i; j ++ {
}
}
//再通过对该算法的规律（单调性等）来优化算法
for(int i = 0; i < n; i ++ ){
while(j <= i && check(i, j)){
j ++ ;
}
}六、位运算
代码思想：掌握针对二进制的一些运算操作。
位运算：
求n的第k位数字：n >> k & 1
返回n的最后一位1：lowbit(n) = n & -n七、离散化算法
代码思想 ：离散化的本质是映射，即将很大范围内间隔很大的各个值，映射到元素相邻的数组中，减少对空间的需求。首先存储所有待离散化的值，排序并且去重，利用二分查找算出对应离散化的值，然后可对离散化后的序列进行相应的操作从而实现对简化对原巨巨巨大的范围的运算。
代码模板（针对某一题目的模板方便理解）：
例题：
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
//将两个元素绑定在一起形成一个合成元素
typedef pair<int, int> PII;
const int N = 3e5 + 10;
int n, m;
int a[N], s[N];
vector<int> alls;
vector<PII> add, query;
//定义二分查找函数找到离散化后的值
int find(int 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;
}
int main(){
cin >> n >> m;
for(int i = 0; i < n; i ++ ){
int x, c;
cin >> x >> c;
add.push_back({x, c});
alls.push_back(x);
}
for(int i = 0; i < m; i ++ ){
int l, r;
cin >> l >> r;
query.push_back({l, r});
alls.push_back(l);
alls.push_back(r);
}
//排序并且去重
sort(alls.begin(), alls.end());
alls.erase(unique(alls.begin(), alls.end()), alls.end());
//处理插入
for(auto item : add){
int x = find(item.first);
a[x] += item.second;
}
//预处理前缀和
for(int i = 1; i <= alls.size(); i ++ ){
s[i] = s[i - 1] + a[i];
}
//处理询问
//for(auto a:b)中b为一个容器，效果是利用a遍历并获得b容器中的每一个值，但是a无法影响到b容器中的元素。
for(auto item : query){
int l = find(item.first), r = find(item.second);
cout << s[r] - s[l - 1] << endl;
}
return 0;
} 注：各个过程的一些处理方式需要记住。
八、区间合并算法
代码思想：该算法较为简单，先持有一个区间，然后与枚举的区间进行对比，若持有区间的end小于枚举区间的start，那么对持有区间进行更新；反之取枚举区间与持有区间的最大的end来进行合并。
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
typedef pair<int, int> PII;
vector<PII> segs;
//区间合并核心代码
void merge(vector<PII> &segs){
vector<PII> res;
sort(segs.begin(), segs.end());
int st = -2e9, ed = -2e9;
for(auto seg : segs)
if(seg.first > ed){
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;
}
int main(){
int n;
cin >> n;
vector<PII> res;
for(int i = 0; i < n; i ++ ){
int l, r;
cin >> l >> r;
segs.push_back({l, r});
}
//计算区间合并后的数量
merge(segs);
cout << segs.size();
return 0;
}注：对所给区间合并前需要进行排序。
总结
截至2023/4/5 跟着Y总把基础算法都学了一遍，感觉还行，继续学把。
唉，简单学习一下算法，记录学习过程为主
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
