算法模板

一、基础算法

1、快排

public static void quickSort(int l, int r, int[] arr) {
        if (l >= r) {
            return;
        }
        int base = arr[(r - l) / 2 + l];
        int i = l - 1, j = r + 1;
        while (i < j) {
            do i++; while (arr[i] < base);
            do j--; while (arr[j] > base);
            if (i < j) swap(i, j, arr);
        }
        quickSort(l, j, arr);
        quickSort(j + 1, r, arr);
    }

2、归并

public static void mergeSort(int l, int r, int[] arr) {
        if (l >= r) {
            return;
        }
        int mid = (l + r) / 2;
        mergeSort(l, mid, arr);
        mergeSort(mid + 1, r, arr);
        int i = l, j = mid + 1, k = 0;
        int[] tmp = new int[r - l + 1];
        while (i <= mid && j <= r) {
            if (arr[i] <= arr[j]) {
                tmp[k++] = arr[i++];
            } else {
                tmp[k++] = arr[j++];
            }
        }
        while (i <= mid) {
            tmp[k++] = arr[i++];
        }
        while (j <= r) {
            tmp[k++] = arr[j++];
        }
        // 最后将临时数组存储到arr中
        for (int m = l, n = 0; m <= r; m++, n++) {
            arr[m] = tmp[n];
        }
    }

3、整数二分

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

// 区间[l, r]被划分成[l, mid]和[mid + 1, r]时使用：
int bsearch_1(int l, int r)
{
    while (l < r)
    {
        int mid = l + r >> 1;
        if (check(mid)) r = mid;    // check()判断mid是否满足性质
        else l = mid + 1;
    }
    return l;
}
// 区间[l, r]被划分成[l, mid - 1]和[mid, r]时使用：
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;
}

4、高精度加法

public static List<Integer> add(List<Integer> v1, List<Integer> v2) {
    List<Integer> v3 = new ArrayList<>();
    // 进位
    int t = 0;
    for (int i = 0, j = 0; i < v1.size() || j < v2.size(); i++, j++) {
        if (i < v1.size() && v1.get(i) > 0) {
            t += v1.get(i);
        }
        if (j < v2.size() && v2.get(j) > 0) {
            t += v2.get(j);
        }
        v3.add(t % 10);
        // 更新t
        t /= 10;
    }
    if (t > 0) {
        v3.add(1);
    }
    return v3;
}

5、高精度减法

public static List<Integer> sub(List<Integer> v1, List<Integer> v2) {
    //  v1 >= v2
    List<Integer> v3 = new ArrayList<>();
    // t是借位，要么为0、要么为1
    int t = 0;
    for (int i = 0; i < v1.size(); i++) {
        // 先处理借位
        t = v1.get(i) - t;
        if (i < v2.size()) t -= v2.get(i);
        v3.add((t + 10) % 10);
        if (t < 0)  {
            t = 1;
        } else {
            t = 0;
        }
    }
    // 处理前导0，可能会有多个前导，所以这里用while比较保险
    while (v3.size() > 1 && v3.get(v3.size() - 1) == 0) {
        v3.remove(v3.size() - 1);
    }
    return v3;
}

public static boolean compare(List<Integer> v1, List<Integer> v2) {
    if (v1 == null) return false;
    if (v2 == null) return true;
    if (v1.size() > v2.size()) return true;
    if (v1.size() < v2.size()) return false;
    // 长度相等，比较每一位
    // 从最高位开始比较
    for (int i = v1.size() - 1; i >= 0; --i) {
        if (v1.get(i) > v2.get(i)) {
            return true;
        } else if (v1.get(i) < v2.get(i)) {
            return false;
        }
    }
    return true;
}

6、高精度乘法

public static List<Integer> mul(List<Integer> v1, int b) {
    List<Integer> v3 = new ArrayList<>();
    int t = 0;
    for (int i = 0; i < v1.size() || t > 0; i++) {
        if (i < v1.size()) t += v1.get(i) * b;
        v3.add(t % 10);
        t /= 10;
    }
    while (v3.size() > 1 && v3.get(v3.size() - 1) == 0) {
        v3.remove(v3.size() - 1);
    }
    return v3;
}

7、高精度除法

public static List<Integer> div(List<Integer> v1, int b) {
    List<Integer> v3 = new ArrayList<>();
    // t代表余数
    int t = 0;
    // 反着做，保证加减乘除的模板都通用
    for (int i = v1.size() - 1; i >= 0; i--) {
        t = t * 10 + v1.get(i);
        v3.add(t / b);
        t %= b;
    }
    // 取反
    Collections.reverse(v3);
    // 取出前导零
    while (v3.size() > 1 && v3.get(v3.size() - 1) == 0) {
        v3.remove(v3.size() - 1);
    }
    return v3;
}

8、一维差分

public static void insert(int l, int r, int c) {
    // 在[l, r]区间上给每个数加上c
    b[l] += c;
    b[r + 1] -= c;
}

9、二维差分

b[x1][y1] += c;
b[x2 + 1][y1] -= c;
b[x1][y2 + 1] -= c;
b[x2 + 1][y2 + 1] += c;