AcWing基础算法

快速排序模板

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int n;
int q[N];

void quick_sort(int q[], int l, int r)
{
    int mid = q[(l + r) / 2];
    int i = l, j = r;
    int tmp;
    while(i < j)
    {
        while(q[i] < mid) i++; 
        while(q[j] > mid) j--; 
        if (i <= j) 
        {
            tmp = q[i];
            q[i] = q[j];
            q[j] = tmp;
            i++;
            j--;
        }
    }
    if (l < j) quick_sort(q, l, j);
    if (i < r) quick_sort(q, i, r);
}
int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &q[i]);
    quick_sort(q, 0, n - 1);
    for (int i = 0; i < n; i++)
        printf("%d ", q[i]);
    return 0;
}

第k个数

#include<iostream>
using namespace std;
const int N = 100010;
int n, k;
int a[N];
int quick_select(int l, int r, int k)
{
    if (l >= r) return a[l];
    int x = a[l];
    int i = l - 1, j = r + 1;
    while (i < j)
    {
        while (a[++i] < x);
        while (a[--j] > x);
        if (i < j) swap(a[i], a[j]);
    }
    int sl = j - l + 1;
    if (k <= sl) return quick_select(l, j, k);
    else return quick_select(j + 1, r, k - sl);
}
int main()
{
    cin >> n >> k;
    for (int i = 0; i < n; i++) cin >> a[i];
    cout << quick_select(0, n - 1, k) << endl;
    return 0;
}

归并排序模板

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int n;
int q[N], tmp[N];
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];
}
int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &q[i]);
    merge_sort(q, 0, n - 1);
    for (int i = 0; i < n; i++)
        printf("%d ", q[i]);
    return 0;
}

求逆序对

#include<iostream>
using namespace std;
typedef long long LL;
const int N = 1e5 + 5;
int n;
int q[N], tmp[N];
LL merge_sort(int q[], int l, int r)
{
    if (l >= r) return 0;
    int mid = l + r >> 1;
    LL res = 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 {
            res += mid - i + 1;
            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];
    return res;
}
int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        scanf("%d", &q[i]);
    printf("%lld", merge_sort(q, 0, n - 1));
    return 0;
}

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

const int N = 100010;
int a[N], n;
int t[N];
long long ans;

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

    i = l, j = 0;
    while (i <= r) {
        a[i++] = t[j++];
    }
}

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
    ans = 0;
    merge_sort(0, n - 1, a);
    printf("%lld\n", ans);

    return 0;
}

二分查找模板

整数二分模板

二分模板一共有两个，分别适用于不同情况。
算法思路：假设目标值在闭区间[l, r]中， 每次将区间长度缩小一半，当l = r时，我们就找到了目标值。

版本1
当我们将区间[l, r]划分成[l, mid]和[mid + 1, r]时，其更新操作是r = mid或者l = mid + 1;，计算mid时不需要加1。

C++ 代码模板：

int bsearch_1(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, r]划分成[l, mid - 1]和[mid, r]时，其更新操作是r = mid - 1或者l = mid;，此时为了防止死循环，计算mid时需要加1。

C++ 代码模板：

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

数的范围

content/791/

#include<iostream>
using namespace std;
const int N = 100010;
int n, m;
int q[N];
int main()
{
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++)
        scanf("%d", &q[i]);
    while (m--)
    {
        int x;
        scanf("%d", &x);
        int l = 0, r = n - 1;
        while (l < r)
        {
            int mid = l + r >> 1;
            // x起始位置 答案在左半边 往后的都大于等于x mid包括在答案里[l,mid]
            if (q[mid] >= x) r = mid;
            else l = mid + 1;
        }
        //找不到 则q[l] != x
        if (q[l] != x) cout << "-1 -1" << endl;
        else
        {
            cout << l << " ";
            
            int l = 0, r = n - 1;
         	while (l < r)
        	{
            	int mid = l + r + 1>> 1;
            	// x最后位置 答案在右半边 之前的都小于等于x mid包括在答案里 [mid,r]
            	if (q[mid] <= x) l = mid;
            	else r = mid - 1;
        	}
            cout << l << endl;
        }
    }
    return 0;
}

浮点数二分模板

bool check(double x) {/* ... */} // 检查x是否满足某种性质

double bsearch_3(double l, double r)
{
    const double eps = 1e-6;   // eps 表示精度，取决于题目对精度的要求 比有效数精度多2
    while (r - l > eps)
    {
        double mid = (l + r) / 2;
        if (check(mid)) r = mid;
        else l = mid;
    }
    return l;
}

数的3次方根

#include<stdio.h>
int main()
{
    double n;
    double l = -10000, r = 10000;
    scanf("%lf", &n);
    while (r - l >= 1e-8)
    {
        double mid = (l + r) / 2;
        if (mid * mid * mid >= n) r = mid;
        else l = mid;
    }
    printf("%lf", l);
    return 0;
}

高精度模板

位数>= 10^6

高精度加法

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

vector<int> add(vector<int> &A, vector<int> &B)
{
    vector<int> C;
    int t = 0; //进位
    for (int i = 0; i < A.size() || 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;
}
    
int main()
{
    string a, b;
    vector<int> A, B;
    
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i--)
        A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i--)
        B.push_back(b[i] - '0');
    
    auto C = add(A, B);
    
    for (int i = C.size() - 1; i >= 0; i--)
        printf("%d", C[i]);
    return 0;
}

高精度减法

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

typedef vector<int> vi;

bool cmp(vi &a, vi &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 true;
}

vi sub(vi &a, vi &b)
{
    vi 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);
        t = t < 0 ? 1 : 0;
    }
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}

int main()
{
    string a, b;
    vi A, B;
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i--) A.push_back(a[i] - '0');
    for (int i = b.size() - 1; i >= 0; i--) B.push_back(b[i] - '0');
    
    if (cmp(A, B))
    {
        auto c = sub(A, B);
        for (int i = c.size() - 1; i >= 0; i--) printf("%d", c[i]);
    }
    else 
    {
        auto c = sub(B, A);
        printf("-");
        for (int i = c.size() - 1; i >= 0; i--) printf("%d", c[i]);
    }
    return 0;
}

高精度乘法

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

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

int main()
{
    string a;
    int b;
    vector<int> aa;
    cin >> a >> b;
    
    for (int i = a.size() - 1; i >= 0; i--) aa.push_back(a[i] - '0')
        
    auto c = mul(aa, b);
    for (int i = c.size() - 1; i >= 0; i--) 
        printf("%d", c[i]);
    return 0;
}

高精度除法

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

typedef vector<int> vi;

vi aa;

// 除数范围小于10000 余数范围也小于10000 r < 10000
vi div(vi &aa, int b, int &r)
{
    vi c;
    int t = 0;
    // 只有除法逆序操作
    for (int i = aa.size() - 1; i >= 0; i--)
    {
        r = r * 10 + aa[i];
        c.push_back(r / b);
        r %= b;
    }
    
    //上面是逆序 所以这里再逆序一下  最后main函数里逆序输出九尾正序结果
    reverse(c.begin(), c.end());
    
    //去除前导0 注意c是最后结果的逆序 注意结果为0的情况 c.size() > 1
    while (c.size() > 1 && c.back() == 0) c.pop_back();
    return c;
}


int main()
{
    string a;
    int b, r;
    cin >> a >> b;
    for (int i = a.size() - 1; i >= 0; i--) aa.push_back(a[i] - '0');
    
    vi c = div(aa, b, r);
    for (int i = c.size() - 1; i >= 0; i--) printf("%d", c[i]);
    printf("\n%d", r);
    return 0;
}

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

// A/b 商是C，余数r
vector<long long> div(vector<long long> &a, long long b, long long &r)
{
    vector<long long> 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;
}

int main()
{
    string a;
    long long b;
    cin >> a >> b;
    vector<long long> aa;
    for (int i = a.size() - 1; i >= 0; i--) 
        aa.push_back(a[i] - '0');
    long long r;
    auto c = div(aa, b, r);
    for (int i = c.size() - 1; i >= 0; i--)
        printf("%lld", c[i]);
    // cout << endl << r << endl;
    return 0;
}

前缀和

一维前缀和

S[i] = a[1] + a[2] + ... a[i]
a[l] + ... + a[r] = S[r] - S[l - 1]

#include<iostream>
using namespace std;
const int N = 1e6 + 10;
int s[N], a[N];
int main()
{
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        cin >> a[i];
    for (int i = 1; i <= n; i++)
        s[i] = s[i - 1] + a[i - 1];
    while (m--)
    {
        int l, r;
        cin >> l >> r;
        cout << s[r] - s[l - 1] << endl;
    }
    return 0;
}

二维前缀和

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]

#include <iostream>
using namespace std;

const int N = 1005;
int s[N][N];
int n, m, q;

int main()
{
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            cin >> s[i][j];
            s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
        }
    
    while (q--)
    {
        int x1, y1, x2, y2;
        cin >> x1 >> y1 >> x2 >> y2;
        cout << s[x2][y2] - s[x1 - 1][y2] - s[x2][y1 - 1] + s[x1 - 1][y1 - 1] << endl;
    }
    
    return 0;
}

激光炸弹

#include<iostream>
using namespace std;
const int N = 5002;
int s[N][N];
int n, r, x, y, w;
int main()
{
    int maxw = 0;
    scanf("%d%d", &n, &r);
    r = min(5001, r);
    while(n--)
    {
        scanf("%d%d%d", &x, &y, &w);
        s[x + 1][y + 1] += w;
    }
    for (int i = 1; i <= 5001; i++)
        for (int j = 1; j <= 5001; j++)
        s[i][j] += s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1];
    for (int i = r; i < N; i++)
    {
        for (int j = r; j < N; j++)
        {
            maxw = max(s[i][j] - s[i - r][j] - s[i][j - r] + s[i - r][j - r], maxw);
        }
    }
    cout << maxw;  
    return 0;
}

差分

一维差分

给区间[l, r]中的每个数加上c：B[l] += c, B[r + 1] -= c

#include<iostream>
using namespace std;

const int N = 1e6 + 5;
int a[N], q[N];

void insert(int l, int r, int c)
{
    b[l] += c;
    b[r + 1] -= c;
}
int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++)
        scanf("%d", &a[i]);
    //构造差分数组b
    for (int i = 1; i <= n; i++)
        insert(i, i, a[i]);
    while (m --)
    {
        int l, r, c;
        scanf("%d%d%d", &l, &r, &c);
        insert(l, r, c);
    }
    for (int i = 1; i <= n; i++)
        b[i] += b[i - 1];
    for (int i = 1; i <= n; i++)
        printf("%d ", b[i]);
    return 0;
}

二维差分

给以(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

#include<iostream>
using namespace std;
const int N = 100010;
int n, m, q;
int a[N][N], b[N][N];
void insert(int x1, int y1, int x2, int y2, int c)
{
    b[x1][y1] += c;
    b[x1][y2 + 1] -= c;
    b[x2 + 1][y1] -= c;
    b[x2 + 1][y2 + 1] += c;
}
int main()
{
    cin >> n >> m >> q;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            cin >> a[i][j];
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            insert(i, j, i, j, a[i][j]);
    while (q--)
    {
        int x1, y1, x2, y2, c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        insert(x1, y1, x2, y2, c);
    }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            b[i][j] += b[i][j - 1] + b[i - 1][j] - b[i - 1][j - 1];
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            cout << b[i][j] << ' ';
        }
        cout << endl;
    }
    return 0;    
}

双指针

模板

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

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

最长连续不重复子序列

#include <iostream>
using namespace std;

const int N = 100005;
int cnt[N], a[N];
int n;

int main()
{
    cin >> n;
    int res = 0;
    for (int i = 0; i < n; i++) cin >> a[i];
    for (int i = 0, j = 0; i < n; i++)
    {
        // i为终点，j为起点
        cnt[a[i]]++;
        // 遇到重复的元素 j往后移 同时重复的元素的个数-1
        while (cnt[a[i]] > 1) cnt[a[j++]]--;
        // 枚举从起点到终点的距离的最大值
        res = max(res, i - j + 1);
    }
    cout << res;
    return 0;
}

数组元素的目标和

#include <iostream>
using namespace std;
const int N = 100005;
int a[N], b[N];

int main()
{
    int n, m, x;
    cin >> n >> m >> x;
    for (int i = 0; i < n; i++) cin >> a[i];
    for (int j = 0; j < m; j++) cin >> b[j];
    
    int i = 0, j = m - 1;
    //从两端枚举
    while (i < n && j >= 0)
    {
        // 和大于x, j向前移动
        while (a[i] + b[j] > x) j--;
        // 和小于x, i向后移动
        while (a[i] + b[j] < x) i++;
        if (a[i] + b[j] == x) 
        {
            cout << i << ' ' << j;
            break;
        }
    }
    
    return 0;
}

位运算

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

二进制数中1的个数

#include<iostream>
using namespace std;
int lowbit(x)
{
    return x & -x;
}
int main()
{
    int n;
    cin >> n;
    while (n--)
    {
        int x;
        cin >> x;
        
        int res = 0;
        while (x) 
        {
            x -= lowbit(x);
            res++;
        }
        
        cout << res << ' ';
    }
    return 0;
}

离散化

模板

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
}

区间和

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
typedef pair<int, int> PII;
const int N = 300010;
// 存储所有下标
vector<int> alls;
// 存储添加 查询操作
vector<PII> add, query;
int a[N], s[N];
// 寻找离散后的索引+1
int find(int x)
{
    int l = 0, r = alls.size() - 1;
    while (l <= r)
    {
        int mid = (l + r) >> 1;
        // 离散后的索引+1
        if (alls[mid] == x) return mid + 1;
        else 
        {
            if (alls[mid] < x) l = mid + 1;
            else r = mid - 1;
        }
    }
    return 0;
}
int main()
{
    int n, m;
    cin >> n >> m;
    while (n--)
    {
        int x, c;
        cin >> x >> c;
        add.push_back({x, c});
        //存储所有下标
        alls.push_back(x);
    }
    while (m--)
    {
        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.begin(), alls.end()), 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;    
}

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];
    }
    return a.begin() + j;
}

区间合并

模板

// 将所有存在交集的区间合并
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;
}

#include<iostream>
#include<vector>
#include<algorithm>
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;
    // 初始化左右边界 
    int st = -2e9, ed = -2e9;
    sort(segs.begin(), segs.end());
    for (auto seg : segs)
    {
        if (ed < seg.first)
        {
            //不把最初的区间(st, ed)放进去
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first;
            ed = seg.second;
        }
        //更新右边界
        else ed = max(ed, seg.second);
    }
    //防止输入的没有任何区间
    //因为之前存储的都是前一个区间，所以最新的，最后一个独立的区间并没有被合并进去，所以要在出循环后在判断一次是否添加最后一个区间，如果这个区间不为空则添加进去
    //本题中 n≥1，所以if可以去掉。但如果 n=0，去掉以后会有问题
    if (st != -2e9) res.push_back({st, ed});
    segs = res;
}
int main()
{
    cin >> n;
    while (n--)
    {
        int l, r;
        cin >> l >> r;
        segs.push_back({l, r});
        
        merge(segs);
        cout << segs.size() << endl;
        return 0;
    }
}

校门外的树

思路
首先先把每个区间合并，再依次区间内的所有点数。

代码

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

typedef pair<int, int> pii;
vector<pii> segs;

// 合并区间
void merge(vector<pii> &segs)
{
    vector<pii> res;
    int st = -1, ed = -1;
    for (auto seg : segs)
    {
        if (ed < seg.first)
        {
            if (~st) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);
    }
    if (~st) res.push_back({st, ed});
    segs = res;
}

int main()
{
    int l, m;
    cin >> l >> m;
    while (m--)
    {
        int st, ed;
        cin >> st >> ed;
        segs.push_back({st, ed});
    }
    
    sort(segs.begin(), segs.end());
    merge(segs);
    
    // 0~l一共有l + 1棵树
    l += 1;
    
    for (auto seg : segs)
    {
        // cout << seg.first << ' ' << seg.second << endl;
        l -= (seg.second - seg.first + 1);
    }
       
        
    cout << l << endl;
    return 0;
}