算法基础课-基础算法

第一章 基础算法

1·快速排序

大体步骤

1. 选取一个元素x作为分界点
2. 对整个数组进行划分：使得成为两部分，前一部分全部小于等于x，后一部分全部大于等于x
3. 每次截取一半，递归处理

代码细节

• 进行第二部的划分时，考虑使用两个指针，分别从数组的开头和数组的末尾向中心行进，当两个指针相遇或者错过时表示操作完毕
• 额外空间复杂度$O(1)$,时间复杂度$O(nlogn)$

代码模板

void quick_sort(int q[],int l,int r){
	if(l>=r) return;//没有数了，返回
	int x = q[l],i = l-1,j = r+1;//注意这里取了左端点
	while(i < j){
		while(q[++i] < x);
		while(q[--j] > x);
	  if(i<j) swap(q[i],q[j]);
	}
	quick_sort(q,l,j);//注意把j作为新的端点
	quick_sort(1,j+1,r);
}

注意事项

• 注意陷入死循环，如果每次选择 q[l]作为分界点时，需要在更新端点时使用j和j+1

2·归并排序

归并排序是经典的分支策略，就是不断地进行分治和merge
同时也是非常经典的双指针算法
大体步骤：

1. 确定分界点，在这里选取数组的中点
2. 分别排序左右两边
3. 归并

代码细节：

• 主要是如何实现merge，用到了两个指针
• 额外空间复杂度$O(n)$,时间复杂度$O(nlogn)$

代码模板

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]) temp[k++] = q[i++];
		else temp[k++] = q[j++];
	}
	while(i<=mid) temp[k++] = q[i++];
	while(j<=r) temp[k++] = q[j++];
	for(i = l,j = 0;i<=r;i++,j++) q[i] = temp[j];
}

3二分算法

关于二分的本质的说明

• 有单调性一定可以二分，但是二分的本质并不是单调性

• 本质：在一段区间上定义一个性质，该性质的特点是在区间上，左半边是不满足的，而右半边是满足的。即该性质将区间一分为二。二分就是用来寻找这种性质在区间内的边界

  • 注意复杂的地方：在整数二分的情况里，“满足该性质”和“不满足该性质”的边界是两个相邻的点，而不是一个点，所以在整数二分里需要尤其注意边界问题，防止死循环

大体步骤

1. 选定中点
2. check中点是否满足该性质
3. 根据check情况更新区间

整数二分

代码模板

//模板1 r=mid
int bisearch1(int l,int r){
	while(l<r){
		int mid = (l+r) >> 1;
		if(check(mid)) r = mid;
		else l = mid + 1;
	}
	return l;
}

//模板2 l=mid
int bisearch2(int l,int r){
	while(l<r){
		int mid = (l+r+1) >> 1;
		if(check(mid)) l = mid;
		else r = mid - 1;
	}
	return l;
}

代码细节

• 有两个模板，一个是除以2上取整，一个是除以2下取整，这就是为了防止死循环
• 具体实操里，是根据自己写的check()函数。来判断是l=mid还是r=mid

浮点二分

代码细节

• 浮点的区间长度可以严格二分
• 需要给定一个精度,在经验上，总是要给出比题目要求多二位的精度

代码模板

double float_bisearch(double l,double r,double DELTA){
	while(r-l>DELTA){
		double mid = (l+r)/2;
		if(check()) r=mid //这里是根据check函数具体调整的
		else l = mid;
	}
	return r;
}

4·高精度

大体步骤：

• 面对足够大的整数，做法是开辟一个数组来逐位储存各位数，并且模拟人算数的形式
• 储存的时候逆序存比较好，方便进位
• 选用STL的vector最方便

高精度加法

代码细节

• 用$t$储存进位，计算$A_i+B_i+t$，则第$i$位答案为$(A_i+B_i+t)\%10$进位为为$(A_i+B_i+t)/10$

代码模板：

//C = A+B
vector<int> add(vector<int> &A,vector<int> &B){
	vector<int> C;
	int t = 0;
	for(int i = 0;i < A.size() || i < N.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；
}

高精度减法

代码细节

• 保证$A\ge B$，否则交换减数和被减数，并且在结果前加负号
• 判断是否需要借位；
• 去除结果的前导0

代码模板

//判断大小,判断是否有A>=B
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 ture; //如果每位都相等，返回真
}

//C = A - B
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];//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();//去除多余·1的前导0
	return C;
}

高精度乘法（一个高精度乘正常整数）

代码细节

• 用A的每一位去乘B的整体

代码模板

vector<int> mul(vector<int> &A,int b){
	vector<int> C;
	int t = 0;//记录进位和临时结果；
	for(int i = 0;i < A.size() || t;i++){//注意附加的条件，只要t还没变成0，就狠狠地循环
		if(i < A.size()) t += A[i]*b;
		C.push_back(t & 10);
		t /= 10;//这下进位的话就不仅限于1,0了，可能会非常大
	}
	return C；
}

高精度除法（一个高精度除以正常整数）

代码细节

• 继续进行模拟，就是大除法竖式的模拟
• 需要返回一个商和一个余数

代码模板

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();//去除前导0
    return C;
}

5·前缀和

前缀和、差分，相较于具体的算法，更像是一种关于“变化”的思想。前缀和是积累变化，差分是剥离变化。

另外通过前缀和与差分，有一些问题也会转化成为等价的问题。比如购买股票的问题，通过差分化，就成为了最大连续子序列和的题

一维前缀和

概念：对于数列 { a i }   S i = Σ 1 i a i \{ a_i\} \ S_i = \Sigma ^{i}_{1} a_i {ai​} Si​=Σ1i​ai​
大体步骤：递推

• $S_0=0$
• $S_i=S_{i-1}+a_i$

基本作用：${\Sigma }_l^r{a}_i=S_r-S_{l-1}$这样计算区间和就是$O(1)$的时间复杂度

二维前缀和

区别并不大，最大的区别是需要考虑容斥了，只要考虑了容斥，就可以比较自然的拓展到更高维

概念&递推：$S_{i,j}=S_{i-1,j}+S_{i,j-1}-S_{i-1,j-1}+a_{i,j}$
基本作用：${\Sigma }_{j=y_1}^{y_2}{\Sigma }_{i=x_{!}}^{x2}{a}_{i,j}=S_{i,j}-S_{i,j-1}-S_{i-1,j}+S_{i-1,j-1}$

6·差分

差分和前缀和类似一对逆运算，其实十分接近于微分和积分的操作。

拓展阅读：见《具体数学》

一维差分

构造：模仿逆运算

• 一开始假装原数组 { a i } \{a_i\} {ai​}和差分 { b i } \{b_i\} {bi​}都是$0$

• 那么接下来需要进行这样的操作：把区间$[i,i]$加上值$a_i$

  • 先思考，如何通过操作 { b i } \{b_i\} {bi​}来将原数组的区间$[l.r]$上整体加上常数$c$
  • 方法是$b_i+c,b_{r+1}-c$

• 综合以上方法得到 { b i } \{b_i\} {bi​}的构造

二维差分

一样的，需要思考容斥

构造:

• 让矩阵$左上角(x_1,y_1)到右下角(x_2,y_2)$加上常数$c$

• 通过$b_{x_1,y_1}+c,b_{x_2+1,y_1}-c,b_{x_1,y_2+1}-c,b_{x_2+1,y_2+1}+c$

7·双指针

类型：

• 分别指向两个序列
• 指向一个序列指针
• ……

伪代码模板：

//这个是i比j在前
for(i = 0,j = 0;i < n;i++){
	while(j < i&& check(i,j)) j++;
	//每道题的具体逻辑
}

注意，双指针算法又是一种思想，没有一个具体的模板，具体应用还是需要题目积累

例题
想法：

• 用一个双指针来维护一段区间$[j,i]$，其中没有重复元素，长度为$j-i+1$

  • 需要一个容器来记录$[j,i]$内各元素出现的次数，以判断是否出现重复元素

• 一开始只不断向右移动$j$

• 若$a_i$的加入使得出现了重复，那就开始移动$j$，并且更新各元素的出现次数，直到区间内没有重复元素

• 每次维护好一段区间，都更新最长长度

代码：

# include <iostream>
using namespace std;

const int N = 100010;
int a[N], s[N];

int main()
{
    int n, length = 0;
    cin >> n;

    for (int i = 0, j = 0; i < n; ++ i)
    {
        cin >> a[i];
        s[a[i]] == 1;
        while (s[a[i]] > 1) {
        	s[a[j]] -= 1;//更新出现次数
        	j++;右移
        } // 先减次数后右移
        length = max(length, i - j + 1) ;//更新最大长度
    }
    cout << length;
    return 0;
}

8·位运算

代码模板

• n的二进制表示，第k位是是什么

  int what(int n,int k){
  	return (n >> k & 1);//把第k位右移到最后一位
  }
  

• 返回x的最右一位1，向右的切片：lowbit

  • x=101000 , lowbit(x) = 1000
  • 树状数组的基本操作

  int lowbit(int x){
  	return （x & (~x + 1)）;
  }
  
  //等价于 x & -x;
  

9·离散化

解决了，值域跨度大 和 数据个数稀疏的矛盾。将一个序列，保序地，映射到，从1开始的自然数序列

如果数据的相对顺序要比绝对大小重要，就用到离散化

大体步骤;

• 排序所有数据
• 去掉所有重复的值
• 实现一个映射（查找）函数（二分法）

代码模板;

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

// 二分求出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
}

题外话：实现unique:

• 对于一个排好序的数组，那些满足$a_i\ne a_{i-1}$的$a_i$，就构成一个不重复的新序列

vector<int>::iterator unique(vector<int> &a){
	int j = 0;
	for(int i = 0;i < a;i++){
		if(i!=1 || a[i] != a[i-1])
			a[j++] = a[i];
	}
	return a.begin() + j;
}

10·区间合并

把能并的区间，都并起来

贪心

1. 按区间左端点排序
2. 维护当前区间$[st,ed]$,对于目前扫描的区间$[l,r]$，其中$l>st$
   • $ifl\le ed$
     • $ifr\le ed$ 当前区间不变
     • $ifr>ed$ 更新 $ed=r$
   • $ifl>ed$ 当前区间不会再增长了 ，可以作为结果之一。更新$st=l,ed=r$

代码：

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

typedef pair<int,int> PII;
const int N = 100010;

int n;
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(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;
}

int main(){
	cin >> n;
	
	for(int i = 0;i < n;i++){
		int l, r;
		cin>>l>>r;
		segs.push_back({l,r});
	}
	merge(segs);
	cout << segs.size() << endl;
	return 0;
}