基础算法

快速排序

void quick_sort(int a[],int l,int r){
   	if(l >= r) return;
    int i = l - 1, j = r + 1;
    int x = a[l + r >> 1]; //这里向下取整，因为后面用到的是j,如果是用的i，则应该是int x = a[l + r + 1 >> 1];
    while(i < j){
        do i++; while(a[i] < x);
        do j--; while(a[j] > x);
        if(i < j) swap(a[i],a[j]);
    }
    quick_sort(a,l,j);
    quick_sort(a,j+1,r);
    //如果是采用i
    //quick_sort(a,l,i-1);
    //quick_sort(a,i,r);
}

归并排序

void merge_sort(int a[],int l,int r){
    if(l >= r) return ;
    int mid = l + r >> 1;
    merge_sort(a,l,mid);
    merge_sort(a,mid+1,r);
    int k = 0, i = l, j = mid + 1;
    while(i <= mid && j <= r){
        if(a[i] < a[j]) tmp[k++] = a[i++];
        else tmp[k++] = a[j++];
    }
    while(i <= mid) tmp[k++] = a[i++];
    while(j <= r) tmp[k++] = a[j++];
    for(int i = l, j = 0; i <= r; ++i,++j) a[i] = tmp[j];
}

整数二分

//有单调性一定能二分，能二分不一定有单调性
bool check(int x){/*...*/} //检查x是否满足某种性质
//模板1
int bsearch_1(int l,int r){
    while(l < r){
        int mid = l + r >> 1;
        if(check) l = mid+1;
        else r = mid;
    }
    return l;
}
//模板2
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;
}

浮点数二分

bool check(double x){/*...*/} //检查x是否满足某种性质
double bsearch_3(double l,double r){
    const double eps = 1e-6;  //eps表示精度，取决于题目对精度的要求
    while(r - l > eps){
        double mid = (l + r ) / 2;
        if(check(mid)) r = mid;
        else l = mid;
    }
    return l;
}

高精度

//加法 A > 0,B > 0
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(t);
    return C;
}
//减法 A > 0, B > 0, A >= B
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;
    }
    while(C.size() > 1 && C.back() == 0) C.pop_back();  //去除前导0
    return C;
}
//乘法 A > 0, b > 0 且b是一个较小的数
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;
}
//除法 A > 0, b > 0 且b是一个较小的数,为了和前面模板对应,除法也采用逆序进行存储
vector<int> div(vector<int> &A,int b,int &r){
    vector<int> C;
    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; 
}

前缀和

//一维前缀和作用：用于快计算数组中的一段区间和
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;

双指针算法

for (int i = 0, j = 0; i < n; i ++ )
{
    while (j < i && check(i, j)) j ++ ;

    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

位运算

求n的第k位数字: n >> k & 1
返回n的最后一位1：lowbit(n) = n & -n

离散化

vector<int> alls; //存储所有待离散的值
sort(alls.begin(),alls.end()); //将所有值排序
alls.erase(unique(alls.begin(),alls.end())),alls.end());//去重

//二分求出对应离散化的值
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 l + 1;
}

区间合并

void merge(vecot<PII> &segs){
    vector<PII> res;
    sort(segs.begin(),segs.end());
    int st = -2e9, ed = -2e9;
    for(auto item : segs){
        if(item.first > ed){
            if(st != -2e9) res.push_back({st,ed});
            st = item.first, ed = item.second;
        }else{
            ed = max(ed,item.second);
        }
    }
    if(st != -2e9) res.push_back({st,ed});
    segs = res;
}