快速排序

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