1排序
1快排
时间复杂度
稳定性:不稳定
注意:边界问题
void quick_sort1(int arr[],int l,int r)
{
if(l>=r)return;
int x=arr[l],i=l-1,j=r+1;
while(i<j)
{
do i++;while(arr[i]<x);
do j--;while(arr[j]>x);
if(i<j)swap(arr[i],arr[j]);
}
quick_sort(arr,l,j);
quick_sort(arr,j+1,r);
}
void qick_sort1(int arr[],int l,int r)
{
if(l>=r)return;
int x=arr[r],i=l-1,j=r+1;
while(i<j)
{
do i++;while(arr[i]<x);
do j--;while(arr[j]>x);
if(i<j)swap(arr[i],arr[j]);
}
quick_sort(arr,l,i-1);
quick_sort(arr,i,r);
}
void quick_sort1(int arr[],int l,int r)
{
if(l>=r)return;
int x=arr[(l+r)/2],i=l-1,j=r+1;
while(i<j)
{
do i++;while(arr[i]<x);
do j--;while(arr[j]>x);
if(i<j)swap(arr[i],arr[j]);
}
quick_sort(arr,l,j);
quick_sort(arr,j+1,r); //i或j都可以
}
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];
}
3 c++库函数sort
sort与归并,快排速度基本上相差无几
2二分法
1:整数二分
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;
}
2:浮点数二分
bool check(double x) {/* ... */} // 检查x是否满足某种性质
double bsearch_3(double l, double r)
{
const double eps = 1e-6; // eps 表示精度,取决于题目对精度的要求 一般比题目要求多1e+2基本上够了
while (r - l > eps)
{
double mid = (l + r) / 2;
if (check(mid)) r = mid;
else l = mid;
}
return l;
}
3高精度问题
1加法
/ 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;
}
2减法
// 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;
}
3乘法
// 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;
}
4除法
// 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;
}
4前缀和与差分
前缀和与差分
一维前缀和
S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 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]
一维差分
给区间[l, r]中的每个数加上c:B[l] += c, B[r + 1] -= c
二维差分
给以(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
5离散化
什么是离散化:离散化就是把一些很散的点从行分配
例如:1,3252,1e+8,1e+5 这些点的数量很少,但分布范围很广,对应者类问题我们常常用离散化简化问题
离散化的步骤:
1其实就是用一个辅助的数组把你要离散的所有数据存下来。
2然后排序,排序是为了后面的二分。
3去重,因为我们要保证相同的元素离散化后数字相同。
4再用二分把离散化后的数字放回原数组。
离散化模版:
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
}
//把离散后的数字放回原数组
for(auto item : add)
{
int x = find(item.first);
a[x] += item.second;
}
例题:区间和
假定有一个无限长的数轴,数轴上每个坐标上的数都是 0。
现在,我们首先进行 n次操作,每次操作将某一位置 x上的数加 c。
接下来,进行 m次询问,每个询问包含两个整数 l和 r,你需要求出在区间 [l,r]
之间的所有数的和。
输入格式:
第一行包含两个整数 n 和 m。
接下来 n行,每行包含两个整数 x和 c。
再接下来 m行,每行包含两个整数 l和 r。
输出格式:
共 m行,每行输出一个询问中所求的区间内数字和。
数据范围
−109≤x≤109,
1≤n,m≤105,
−109≤l≤r≤109,
−10000≤c≤10000
输入样例:
3 3
1 2
3 6
7 5
1 3
4 6
7 8
输出样例:
8
0
5
代码:
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, int> PII;
const int N = 300010;
int n, m;
int a[N], s[N]; //a存储离散化的数,s存储前缀和
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;
}
vector<int>::iterator unique(vector<int> &a) //去重的具体实现方法
{
int j = 0;
for (int i = 0; i < a.size(); i ++ )
if (!i || a[i] != a[i - 1])
a[j ++ ] = a[i];
// a[0] ~ a[j - 1] 所有a中不重复的数
return a.begin() + j;
}
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), 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 item : query)
{
int l = find(item.first), r = find(item.second);
cout << s[r] - s[l - 1] << endl;
}
return 0;
}
6区间合并(普通做法和贪心)
题目:
给定 n
个区间 [li,ri]
,要求合并所有有交集的区间。
注意如果在端点处相交,也算有交集。
输出合并完成后的区间个数。
例如:[1,3]
和 [2,6]
可以合并为一个区间 [1,6]
。
输入格式
第一行包含整数 n
。
接下来 n
行,每行包含两个整数 l
和 r
。
输出格式
共一行,包含一个整数,表示合并区间完成后的区间个数。
数据范围
1≤n≤100000
,
−109≤li≤ri≤109
输入样例:
5
1 2
2 4
5 6
7 8
7 9
输出样例:
3
普通:
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef pair<int, int> PII;
int n;
void merge(vector<PII> &interval)
{
vector<PII> ans;
sort(interval.begin(), interval.end()); //! pair排序 优先左端点, 再以右端点排序
int st = -1e9-10, ed = -1e9-10; //! 只要比 -1e9 小就可以
for(auto item:interval)
{
if(ed<item.first) //! 第一段区间一定是 ed< item.first
{
if(st!=-1e9-10) ans.push_back({st,ed}); //! 第一次在这里初始化
st = item.first, ed = item.second;//! 第一段区间从这里开始
}
else ed = max(ed, item.second);
}//todo 这个循环结束之后还会剩下一个区间
if(st!=-1e9-10) ans.push_back({st,ed}); //! 如果不是空的 那我们就加上一段
interval = ans;
}
int main(void)
{
ios::sync_with_stdio(false); //优化cin的速度
cin >> n;
vector<PII> interval;
while(n--)
{
int l, r;
cin >> l >> r;
interval.push_back({l, r});
}
merge(interval);
cout << interval.size() << endl;
return 0;
}