常见算法集合

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;
}