经典算法详解-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_40037938/article/details/118002181

算法基础

排序

快速排序

把每个比基准值大的值放到右边，比基准值小的值放到左边，再分别左右快速排序

void quick_sort(int q[], int l, int r) {
	if (l >= r) return;
  
  int x = q[l], i = l - 1, j = r + 1; //这里基准点l必须上取整，不然会死循环 
  int x = q[l + r >> 1], i = l - 1, j = r + 1; //似乎比上一行的写法更快，快速排序最坏情况是 O(n2)，上一行更容易导致接近最坏情况
  // 假如是 1，2 进行快速排序，会出现排序一次后，左边界是 [0,-1]， 右边是[0,2]，会一直死循环
  while (i < j) {
    do i++; while (q[i] < x);
    do j--; while (q[j] > x);
    if (i < j) swap(q[i], q[j]);
  }
  
  quick_sort(q, l, j);
  quick_sort(q, j + 1, r);
}

归并排序

确定分界点 mid = (l + r) / 2
归并排序 left right
归并 - 合二为一

const int N = 1000010;
int n;
int q[N], tem[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 = 1, j = mid + 1;
  while (i <= mid && j <= r) 
    if (q[i] <= q[j]) tmp[k ++] = q[i ++];
  	else tem[k ++] = q[j ++];
  while (i <= mid) tem[k ++] = q[i ++];
  while (j <= r) tem[k ++] = q[j ++];
    
  for (int i = l, j = 0; i <= r; i ++, j ++) q[i] = tem[j];
}

二分查找

int bsearch_1(int l, int r) {
  while (l < r) {
    int mid = l + r >> 1;
    if (check(mid)) r = mid; //判断mid是否满足某种性质
    else l = mid + 1;
  }
  return l;
}

int bsearch_2(int l, int r) {
  while (l < r) {
    int mid = l + r + 1 >> 1; //除法是下取整，如果不加1 且 l = r - 1，那么区间[l, r]会变成区间[l, r]会进入死循环，因为 mid = l + r >> 1 = l + 1 + l >> 1 = l。所以当 l = mid 时，需要补偿 1
    if (check(mid)) l = mid; // l = mid 的话需要 + 1
    else r = mid - 1;
  }
  return l;
}

高精度

使用数组存储高精度数字的时候，例如 12345 保存成 54321，可以实现高位对齐

加法

先逆序存储数字，然后计算加法，如果末尾有进位，则补1

#include <iostream>
#include <vector>

using namespace std;
const int N = 1e6 + 10;

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 > 0) c.push_back(1);
    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;
}

减法

Ai - Bi - t >= 0，直接减，否则 10 + Ai - Bi - t

如果小的减去大的，反过来求减法

#include <iostream>
#include <vector>

using namespace std;
const int N = 1e6 + 10;

// 判断 A是否大于B
bool cmp(vector<int> &A, vector<int> & 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;        
}

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(); //把0004 这种结果的前面的0都去除
    
    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');
    
    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("%c", '-');
        for (int i = c.size() - 1; i >= 0; --i) printf("%d", c[i]);
    }
    return 0;
}

乘法

#include <iostream>
#include <vector>

using namespace std;
const int N = 1e6 + 10;

vector<int> mul(vector<int> &A, int b) {
    vector<int> c;
    int t  = 0;
    for (int i = 0; i < A.size(); ++i) {
        t += A[i] * b; // 把小的数b当作一个整体相乘
        c.push_back(t % 10);
        t /= 10;
    }
    if (t > 0) c.push_back(t);
    while (c.size() > 1 && c.back() == 0) c.pop_back(); // 去除末尾的00001
    return c;
}

int main () {
    string a;
    int b; // 大a 小b
    vector<int> A;
    cin >> a >> b;
    // 存入逆序的大数字 
    for (int i = a.size() - 1; i >= 0; --i) A.push_back(a[i] - '0');
    auto c = mul(A, 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;
const int N = 1e6 + 10;

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(); // 去除末尾的00001
    return c;
}

int main () {
    string a;
    int b; // 大a 小b
    vector<int> A;
    cin >> a >> b;
    // 存入逆序的大数字 
    for (int i = a.size() - 1; i >= 0; --i) A.push_back(a[i] - '0');
    int r;
    auto c = div(A, b, r);
    for (int i = c.size() - 1; i >= 0; --i) printf("%d", c[i]);
    cout << endl << r << endl;
    return 0;
}

前缀和和差分

前缀和

二维前缀和思路类似。

#include <iostream>
using namespace std;

const int N = 100010;

int n, m;
int a[N], s[N];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i];
    while (m--) {
        int l, r;
        scanf("%d%d", &l, & r);
        printf("%d\n", s[r] - s[l - 1]);
    }
}

差分

#include <iostream>
using namespace std;

const int N = 100010;
int n, m;
int a[N], b[N];

void insert(int l, int r, int c) {
    b[l] += c;
    b[r + 1] -= c;
}

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    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;
}

二维差分

#include <iostream>
using namespace std;

const int N = 1010;
int n, m, q;
int a[N][N], b[N][N];

void insert(int x1, int x2, int y1, int y2, int c) {
   b[x1][y1] += c;
   b[x2 + 1][y1] -= c;
   b[x1][y2 + 1] -= c;
   b[x2 + 1][y2 + 1] += c;
}

int main() {
    scanf("%d%d%d", &n, &m, &q);
    for (int i = 1; i <= n; ++i) 
        for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
    for (int i = 1; i <= n; ++i) 
        for (int j = 1; j <= m; ++j) insert(i, i, j, j, a[i][j]);
    
    while (q--) {
        int x1, y1, x2, y2, c;
        cin >> x1 >> y1 >> x2 >> y2 >> c;
        insert(x1, x2, y1, y2, c);
    }
    
    for (int i = 1; i <= n; ++i) 
        for (int j = 1; j <= m; ++j) 
            b[i][j] += b[i - 1][j] + b[i][j - 1] - b[i - 1][j - 1];
        
    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) printf("%d ", b[i][j]);
        printf("\n");    
    }
    return 0;
}

双指针

求 n 的二进制表示第 K 位是几? 先右移动 k 位，再看个位数是啥

n >> k & 1;

求 k 中有几位1？求个位是否是1，然后右移，直到为0.

原码： 0000 1010

反码： 1111 0101

补码： 1111 0110 反码 + 1

离散化

把不同的值映射到连续数字。

特点：值域大，数字少

存储所有待离散化的值
排序
去重
离散化
二分求出 x 对应的离散化的值

Acwing 802题，数的值域很大，数不多，用前缀和浪费空间，就可用离散化。

#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];

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; //映射到从1开始的自然数
}

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