背算法模板,并且理解代码的思想和流程,背的不是代码,不是单词,而是思路。
针对不同模板做相应的模板题,课下做模板题,针对做过的题,课下把代码删除后再做3~5次。
数据结构与算法可视化网站:https://visualgo.net/zh
数据输入输出大于1e6,建议用scanf,否则cin。
很多难题其实是一些基础算法堆砌而成的,人类做题的过程其实是一个 dfs 的过程,分解的过程中发现有些步骤是一些经典问题:
现在就是把这些叶节点的算法学会,最后如何有机的结合到一起就是难题了。
基于分治思想
(暴力方法:定义两个数组,分别存储左右区间,最后合并)
优美方法:定义两个指针,i、j,分别位于数组两端,向中间移动,直到i、j顺序都不对时,交换i、j的值
void quick_sort(vector<int>&q, int l, int r)
{
if (l >= r) return; //注意这里是>=
int i = l - 1, j = r + 1, x = q[l + r >> 1];
while (i < j)
{
while (q[++i] < x); //注意这里无论结果如何i都会+1,故初始化时i=l-1,且才能跳出循环
while (q[--j] > x);
if (i < j) swap(q[i], q[j]);
}
quick_sort(q, l, j);
quick_sort(q, j + 1, r);
}
快排为不稳定排序,但也可以变为稳定排序,只要将每一个数变为不同就可以,如:将 a[i],变为 < a[i],i >,变为一个二元组,进行双关键字排序即可。
时间复杂度
每一次划分,期望都是 n/2,每次递归的层数,期望是log n。
思路:基于分治思想
void merge_sort(int q[], int l, int r)
{
if (l >= r) return; //return边界
int mid = l + r >> 1;
merge_sort(q, l, mid); //排序左半
merge_sort(q, mid + 1, r); //排序右半
int k = 0, i = l, j = mid + 1; //将i,j分别指向两数组第一个元素
while (i <= mid && j <= r) //若两数组都没结束,选小的进
if (q[i] <= q[j]) tmp[k ++ ] = q[i ++ ];
else tmp[k ++ ] = q[j ++ ];
while (i <= mid) tmp[k ++ ] = q[i ++ ]; //一数组结束,另外一数组剩下元素依次进
while (j <= r) tmp[k ++ ] = q[j ++ ];
for (i = l, j = 0; i <= r; i ++, j ++ ) q[i] = tmp[j];
}
时间复杂度:
n 除了 log n 次可以除到 1,每一层的时间复杂度都是O(n),最后的时间复杂度是:n log n
数据有单调性,一定可以二分,可以二分的题目,并不一定有单调性。
所以二分的本质并不是单调性
二分的本质是:边界,可以划分为满足某种性质与不满足某种性质的两个区间,用二分法可以找到两区间边界的左右两个点。
数据可以划分为红色和绿色两个部分,如果判断不在红色部分,那一定在绿色部分。
1、以红色为边界点
2、以绿色为边界点
一般不需要考虑这么细。
如找到一个数的左右边界,检查的就是是否为当前数,不为则是false
二分的思想:
在一个区间内,去二分找答案,或者边界,每次都是要找答案所在区间,进行二分处理,每次将区间长度缩小一半,每次都一定能保证,区间里面有答案,当区间长度为 1 时,那么区间内一定有答案。
二分是一定有解的,二分无解和模板无关,和题目有关
int bsearch_1(int l, int r) //寻找右边界
{
while (l < r)
{
int mid = l + r + 1 >> 1; //右边界需+1
if (q[mid]>k) r = mid-1; //mid不满足<=,直接将右边界置mid左边
else l = mid; //左边界一点点贴近右边界
}
return l;
}
int bsearch_2(int l, int r) //寻找左边界,同理
{
while (l < r)
{
int mid = l + r >> 1;
if (q[mid]<k) l = mid+1;
else r = mid;
}
return l;
}
void bsearch_3(double l, double r) //所有可能的范围如[-10000,10000]
{
const double eps = 1e-8; //要求精度多两位
while (abs(r - l) > eps)
{
double mid = (l + r) / 2;
if (n-pow(mid,3)<eps) r = mid; //两者不断接近
else l = mid;
}
printf("%lf",r);
}
分为:A + B、A - B、A * a、A / a
void add(vector<int>&a,vector<int>&b){
if(a.size()<b.size()) return add(b,a); //确保a>b,由于都是正整数,所以可以这么操作
int c=0;
for(int i=0;i<a.size();i++){
a[i]+=c; //a+b+c(进位符)
if(i<b.size()) a[i]+=b[i]; //注意a还有,b没了
c=a[i]/10;
a[i]%=10;
}
if(c) a.push_back(1); //注意最后一位进位
for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}
void sub(vector<int>&a,vector<int>&b){
int c=0;
for(int i=0;i<a.size();i++){ //同理变成减
a[i]-=c;
if(i<b.size()) a[i]-=b[i];
if(a[i]<0) c=1;
else c=0;
a[i]=(a[i]+10)%10;
}
while(a.size()!=1&&a[a.size()-1]==0) a.pop_back(); //注意是while不是if,如果高位为0要一直减
for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}
乘法与加法类似,但由长整数乘以短整数,故不是一位乘一位,是以长整数的一位乘整个短整数。
void mult(vector<int>&a,int b){
int c=0;
for(int i=0;i<a.size();i++){
a[i]=b*a[i]; //同理,注意先乘后加
a[i]+=c;
c=a[i]/10;
a[i]%=10;
}
while(c!=0){ //若用新数组保存值每次push_back,for循环条件可以为a.size()||c,减少这个while语句
a.push_back(c%10);
c/=10;
}
while(a.size()!=1&&a.back()==0) a.pop_back();
for(int i=a.size()-1;i>=0;i--) printf("%d",a[i]);
}
模拟除法,从高位开始,(余数*10+高位)除以除数得商的高位,%除数得新的余数,循环。
void div(vector<int>&a,int b){
int t=0;
vector<int> c;
for(int i=0;i<a.size();i++){
t=t*10+a[i];
if(c.size()!=0||t/b!=0) c.push_back(t/b); //用if去除高位的0,可以用reverse函数倒置去0同理
t%=b;
}
if(c.size()==0) c.push_back(0);
for(int i=0;i<c.size();i++) printf("%d",c[i]);
}
假设有一组长度为 n 的数组:a[1],a[2],a[3] …… a[n]。
前缀和数组:S[i] = a[1] + a[2] + … a[I]。前缀和不是一个模板,而是一个公式。
S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]
同理假设有一组二维数组 a[i][j] 。
S[i][j] 代表 从 a[1][1] 到 a[i][j] 所有元素的和,是个矩阵。
以(x1, y1)为左上角,(x2, y2)为右下角的子矩阵的和为:
S[x2, y2] - S[x1 - 1, y2] - S[x2, y1 - 1] + S[x1 - 1, y1 - 1]。
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]
前缀和的逆运算。
假设有一组长度为 n 的数组:a[1],a[2],a[3] …… a[n]。
构造 b 数组:b[1],b[2],b[3] …… b[n]。
使得 a[n] = b[1] + b[2] + b[3] + …… + b[n]。
a 数组是 b 数组的前缀和,b 为 a 的差分。
如果想要将数组 a 中的每一个数 + c,如果遍历来做,时间复杂度为 O(n),用差分来做,时间复杂度为 O(1)。
给区间[l, r]中的每个数加上c:B[l] += c, B[r + 1] -= c
原理:若在a数组的区间[l, r]上依次加val,时间复杂度 O(n);若在b数组上 b[l ] + val、b[r+1] - val,最后求它的前缀和数组 a,[l, r] 区间内得到相同结果,时间复杂度 O(1)。
思路:虽然题目初始化的数组有值,但我们仍初始化一个全0的差分数组b,模拟在 [l, l] 上每一个位置依次进行插入初始值C,然后按题目要求在[l,r]上插入即可;
void insert(int l,int r,int val){ //由于最后结果是前缀和数组,在差分数组l上加val,使得[l, + ∞)上都加val,在r+1上减val得到仅在区间[l,r]上加val
q[l]+=val;
q[r+1]-=val;
}
void insert(int x1,int y1,int x2,int y2,int v){ //注意容斥问题、矩阵从a11开始、矩阵初始化大小行列都得+2
q[x1][y1]+=v;
q[x1][y2+1]-=v;
q[x2+1][y1]-=v;
q[x2+1][y2+1]+=v;
}
第一种对于两个序列,维护某种次序:
在归并排序时,两个数组合并,就是一个双指针算法,两个指针分别位于数组相应的位置,依次向右遍历,当数组执行到尾部,合并完成。
第二种是对于一个序列,用两个指针维护一段区间:
如快排,两个指针分别位于左右两端,依次中间比较交换。
双指针算法最核心的思想就是将原本两层循环 O(n^2) 的算法优化为 O(n)。
只要能够满足以上思想,都可以称为双指针算法。
如下,输入多个单词,每个单词之间都会有一个空格,依次输出单词,每行一个。
for (int i = 0, j = 0; i < n; i ++ )
{
while (j < i && check(i, j)) j ++ ; //寻找i,j的单调关系
// 具体问题的逻辑
}
双指针算法就是针对朴素算法中发现一些性质,尤其是发现一些单调性,使得原本要枚举 O(n^2) 的算法优化为 O(n)。
常见题:
n 的二进制表示数字中,第 k 个数字是多少。
n = 15 = (1111) 2
求二进制中1的个数
lowbit(x):返回x的最后一个1,即101000得1000;
原理:x&-x = x&(~x+1)
int lowbit(int x){
return x & -x;
}
源码:x 的二进制
反码:x 的二进制取反
补码:反码 + 1
场景:目标数据稀疏的分散在大范围的数组空间中,大部分元素为0
如:值域为:1 ~ 10^9 , 个数为:10^5,将这些数进行映射,这个过程就是离散化。
问题:
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
}
如果两个区间有交集,则可以进行区间合并。
// 将所有存在交集的区间合并
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;
}