算法学习ing

时间复杂度估算

$$master公式：T(n)=a\ast T(N/b)+O(N^d)$$

1. log(b,a) > d 复杂度为 O(N^log(b,a))
2. log(b,a) > d 复杂度为 O(N^d * log N)
3. log(b,a) > d 复杂度为 O(N^d)

算法的复杂度与Master定理

排序

归并排序

• 分解（Divide）：将n个元素分成个含n/2个元素的子序列。
• 解决（Conquer）：用合并排序法对两个子序列递归的排序。
• 合并（Combine）：合并两个已排序的子序列已得到排序结果。

#include<iostream>
using namespace std;
const int N = 1e5 + 10;
int arr[N], help[N];

void merge_srot(int l, int r){
    if(l >= r) return; 
    int mid = l + ((r - l) >> 1); // 中点
    merge_srot(l, mid);
    merge_srot(mid + 1, r);
    int k = 0, left = l, right = mid + 1; // 划分左右指针
    while(left <= mid && right <= r) { // 比较左右数字大小再入数组
        help[k++] = arr[left] <= arr[right] ? arr[left++] : arr[right++]; // 根据需要选择是否等于，相等时：若小于则右侧指针移动；小于等于则左侧指针移动
    }
    while(left <= mid) help[k++] = arr[left++];
    while(right <= r) help[k++] = arr[right++]; // 一侧数组比尽，另一侧全入
    for(int i = 0, j = l; j <= r; ) {
        arr[j++] = help[i++]; // 拷贝help数组至arr数组
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0); cout.tie(0);
    int n;
    cin >> n;
    for(int i = 0; i < n; i++ ) {
        cin >> arr[i];
    }
    merge_srot(0, n - 1);
    for(int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    return 0;
}

<

小和问题
在一个数组中， 每一个数左边比当前数小的数累加起来， 叫做这个数组的小和。 求一个数组的小和。
例子：[1, 3, 4, 2, 5]
1左边比1小的数， 没有；
3左边比3小的数， 1；
4左边比4小的数， 1、 3；
2左边比2小的数， 1；
5左边比5小的数， 1、 3、 4、 2；
所以小和为1 + 1 + 3 + 1 + 1 + 3 + 4 + 2 = 16

int arr[N], help[N], sum = 0; // 小和累加 sum

while(left <= mid && right <= r) {
        sum += arr[left] < arr[right] ? arr[left] * (r - right + 1) : 0; // 用左侧数值乘以右侧大于左侧的数量，最后小和相加
        help[k++] = arr[left] < arr[right] ? arr[left++] : arr[right++]; // 排序
    }

其余代码同归并排序代码。

逆序对的数量
给定一个长度为 n 的整数数列，请你计算数列中的逆序对的数量。
逆序对的定义如下：对于数列的第 i 个和第 j 个元素，如果满足 i < j 且 a[i] > a[j]，则其为一个逆序对；否则不是。
输入格式：第一行包含整数 n，表示数列的长度。第二行包含 n 个整数，表示整个数列。
输出格式：输出一个整数，表示逆序对的个数。数据范围 1 ≤ n ≤ 100000，数列中的元素的取值范围 [1,109]。

输入样例：6 2 3 4 5 6 1
输出样例：5

long long sum = 0; // 数据大 则开long long

    while(left <= mid && right <= r) {
        if(arr[left] > arr[right]) sum += mid - left + 1; // 直接计算左边剩余大数的数量
        help[k++] = arr[left] <= arr[right] ? arr[left++] : arr[right++]; // <= 相等数据 左边先入
    }

其余代码同归并排序代码。

快速排序

• 从数列中挑出一个元素，称为 “基准”（pivot），
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

quickSort(int l, int r) {
    if(l >= r) return;
    int i = l - 1, j = r + 1, midNum = arr[l + ((r - l) >> 1)];
    while(i < j) {
        while(arr[++i] < midNum);
        while(arr[--j] > midNum);
        if(i < j) swap(arr[i], arr[j]);
    }
    quickSort(l, j), quickSort(j + 1, r);
}

荷兰国旗问题：
给定一个数组arr，和一个数num，请把小于num的数放在数组的左边，等于num的书放在中间，大于num的数放在右边。
要求：时间复杂度O(n)，额外空间复杂度O(1)

void NetherlandsFlag(int len, int num) {
    int left = -1, current = 0; // (0, left)为小于num的数，current为下标，依次从数组左向右与num比较
    while(current != len) {
        if(arr[current] < num) {
            swap(++left, current++);
        }
        else if(arr[current] == num) current++;
        else if(arr[current] > num){
            swap(--len, current); // 交换数值
        }
    }
}