个人ACM模板总结（JAVA版）（四）

繢鴻

已于 2025-05-26 17:35:43 修改

阅读量316

点赞数 3

CC 4.0 BY-SA版权

文章标签：算法 java 动态规划贪心算法

于 2025-05-26 17:31:36 首次发布

本文链接：https://blog.csdn.net/qq123456xxd/article/details/148234941

个人ACM模板总结（JAVA版）（四）

感谢AcWing - 快乐学习生活，尽在AcWing Acwing这个算法平台。

学习自Acwing + 大佬（青衫白衣98）+ 自己总结

七、其他

（一）排序

1.快速排序

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

    private static void swap(int[] arr, int i, int j) {
   
   
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    public static void main(String[] args) {
   
   
        int[] a = {
   
   5, 3, 8, 4, 2};
        quickSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }
}

2.归并排序

public class MergeSort {
   
   
    private static int[] tmp;

    public static void mergeSort(int[] arr, int l, int r) {
   
   
        if (l >= r) return;
        int m = (l + r) / 2;
        mergeSort(arr, l, m);
        mergeSort(arr, m + 1, r);

        tmp = new int[r - l + 1];
        int i = l, j = m + 1, k = 0;

        while (i <= m && j <= r) {
   
   
            if (arr[i] <= arr[j]) {
   
   
                tmp[k++] = arr[i++];
            } else {
   
   
                tmp[k++] = arr[j++];
            }
        }

        while (i <= m) tmp[k++] = arr[i++];
        while (j <= r) tmp[k++] = arr[j++];

        for (int p = 0; p < tmp.length; p++) {
   
   
            arr[l + p] = tmp[p];
        }
    }

    public static void main(String[] args) {
   
   
        int[] a = {
   
   5, 3, 8, 4, 2};
        mergeSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));
    }
}

3.归并排序求逆序对

public class InversionCount {
   
   
    private static int[] tmp;

    public static long mergeSort(int[] arr, int l, int r) {
   
   
        if (l >= r) return 0;
        int mid = (l + r) / 2;
        long res = mergeSort(arr, l, mid) + mergeSort(arr, mid + 1, r);

        tmp = new int[r - l + 1];
        int i = l, j = mid + 1, k = 0;

        while (i <= mid && j <= r) {
   
   
            if (arr[i] <= arr[j]) {
   
   
                tmp[k++] = arr[i++];
            } else {
   
   
                tmp[k++] = arr[j++];
                res += mid - i + 1;
            }
        }

        while (i <= mid) tmp[k++] = arr[i++];
        while (j <= r) tmp[k++] = arr[j++];

        for (int p = 0; p < tmp.length; p++) {
   
   
            arr[p + l] = tmp[p];
        }

        return res;
    }

    public static void main(String[] args) {
   
   
        int[] a = {
   
   3, 1, 2, 4, 5};
        System.out.println("逆序对数量：" + mergeSort(a, 0, a.length - 1));
    }
}

（二）二分

1.整数二分

public class BinarySearch {
   
   

    // 区间 [l, r] 被划分为 [l, mid] 和 [mid+1, r]
    public static int binarySearch1(int[] arr, int target) {
   
   
        int l = 0, r = arr.length - 1;
        while (l < r) {
   
   
            int mid = (l + r) / 2;
            if (arr[mid] >= target) {
   
   
                r = mid;
            } else {
   
   
                l = mid + 1;
            }
        }
        return l;
    }

    // 区间 [l, r] 被划分为 [l, mid-1] 和 [mid, r]
    public static int binarySearch2(int[] arr, int target) {
   
   
        int l = 0, r = arr.length - 1;
        while (l < r) {
   
   
            int mid = (l + r + 1) / 2;
            if (arr[mid] <= target) {
   
   
                l = mid;
            } else {
   
   
                r = mid - 1;
            }
        }
        return l;
    }
}

2.浮点数二分

public class FloatBinarySearch {
   
   
    public static double binarySearch(double l, double r) {
   
   
        for (int i = 0; i < 100; i++) {
   
   
            double mid = (l + r) / 2;
            if (check(mid)) {
   
   
                r = mid;
            } else {
   
   
                l = mid;
            }
        }
        return l;
    }

    // 示例 check 函数：找 sqrt(2)
    public static boolean check(double x) {
   
   
        return x * x >= 2.0;
    }

    public static void main(String[] args) {
   
   
        System.out.println(binarySearch(1, 2)); // 输出近似值 1.414...
    }
}

（三）快速幂和龟速乘

1. 龟速乘法（防止溢出的大数相乘）

public class SlowMultiply {
   
   
    public static long multiply(long a, long b, long mod) {
   
   
        long res = 0;
        while (b > 0) {
   
   
            if ((b & 1) == 1) {
   
   
                res = (res + a) % mod;
            }
            a = (a + a) % mod;
            b >>= 1;
        }
        return res;
    }
}

2. 快速幂（模幂运算）

public class FastPower {
   
   
    public static long power(long base, long exp, long mod) {
   
   
        long ans = 1;
        while (exp != 0) {
   
   
            if ((exp & 1) == 1) {
   
   
                ans = ans * base % mod;
            }
            base = base * base % mod;
            exp >>= 1;
        }
        return ans;
    }
}

（四）快读

import java.io.*;

public class FastReader {
   
   
    private static BufferedReader reader;
    private static StringTokenizer tokenizer;

    public static void init() {
   
   
        reader = new BufferedReader(new InputStreamReader(System.in));
    }

    public static String next() throws IOException {
   
   
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
   
   
            String line = reader.readLine();
            if (line == null) throw new IOException("No more input");
            tokenizer = new StringTokenizer(line);
        }
        return tokenizer.nextToken();
    }

    public static int nextInt() throws IOException {
   
   
        return Integer.parseInt(next());
    }

    public static long nextLong() throws IOException {
   
   
        return Long.parseLong(next());
    }

    public static double nextDouble() throws IOException {
   
   
        return Double.parseDouble(next());
    }

    public static void main(String[] args) throws IOException {
   
   
        init();
        int n = nextInt();
        System.out.println(n);
    }
}

（五）高精度

_int128 a;//可以防止爆longlong，注意两个

1.大数相加：

import java.util.*;

public class HighPrecisionAddition {
   
   
    public static List<Integer> add(List<Integer> A, List<Integer> B) {
   
   
        List<Integer> C = new ArrayList<>();
        int t = 0; // 进位
        for (int i = 0; i < A.size() || i < B.size(); i++) {
   
   
            if (i < A.size()) t += A.get(i);
            if (i < B.size()) t += B.get(i);
            C.add(t % 10);
            t /= 10;
        }
        if (t > 0) C.add(t);
        return C;
    }

    public static void main(String[] args) {
   
   
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        String s2 = sc.next();

        List<Integer> A = new ArrayList<>();
        List<Integer> B = new ArrayList<>();

        for (int i = s1.length() - 1; i >= 0; i--) A.add(s1.charAt(i) - '0');
        for (int i = s2.length() - 1; i >= 0; i--) B.add(s2.charAt(i) - '0');

        List<Integer> C = add(A, B);

        for (int i = C.size() - 1; i >= 0; i--) {
   
   
            System.out.print(C.get(i));
        }
    }
}

2.高精度减：

import java.util.*;

public class HighPrecisionSubtraction {
   
   
    public static boolean cmp(List<Integer> A, List<Integer> B) {
   
   
        if (A.size() != B.size()) return A.size() > B.size();
        for (int i = A.size() - 1; i >= 0; i--)
            if (!A.get(i).equals(B.get(i))) return A.get(i) > B.get(i);
        return true;
    }

    public static List<Integer> sub(List<Integer> A, List<Integer> B) {
   
   
        List<Integer> C = new ArrayList<>();
        int t = 0;
        for (int i = 0; i < A.size(); i++) {
   
   
            t = A.get(i) - t;
            if (i < B.size()) t -= B.get(i);
            C.add((t + 10) % 10);
            t = t < 0 ? 1 : 0;
        }

        while (C.size() > 1 && C.get(C.size() - 1) == 0)
            C.remove(C.size() - 1);
        return C;
    }

    public static void main(String[] args) {
   
   
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        String s2 = sc.next();

        List<Integer> A = new ArrayList<>();
        List<Integer> B = new ArrayList<>();

        for (int i = s1.length() - 1; i >= 0; i--) A.add(s1.charAt(i) - '0');
        for (int i = s2.length() - 1; i >= 0; i--) B.add(s2.charAt(i) - '0');

        if (cmp(A, B)) {
   
   
            List<Integer> C = sub(A, B);
            for (int i = C.size() - 1; i >= 0; i--) System.out.print(C.get(i));
        } else {
   
   
            List<Integer> C = sub(B, A);
            System.out.print("-");
            for (int i = C.size() - 1; i >= 0; i--) System.out.print(C.get(i));
        }
    }
}

3.高精度除低精度：（返回商和余数）

import java.util.*;

public class HighPrecisionDivision {
   
   
    public static class Result {
   
   
        List<Integer> quotient;
        int remainder;

        public Result(List<Integer> q, int r) {
   
   
            quotient = q;
            remainder = r;
        }
    }

    public static Result divide(List<Integer> A, int b) {
   
   
        List<Integer> C = new ArrayList<>();
        int r = 0;
        for (int i = A.size() - 1; i >= 0; i--) {
   
   
            r = r * 10 + A.get(i);
            C.add(r / b);
            r %= b;
        }
        Collections.reverse(C);
        while (C.size() > 1 && C.get(0) == 0) C.remove(0);
        return new Result(C, r);
    }

    public static void main(String[] args) {
   
   
        Scanner sc = new Scanner(System.in);
        String s1 = sc.next();
        int b = sc.nextInt();

        List<Integer> A = new ArrayList<>();
        for (int i = s1.length() - 1; i >= 0; i--) A.add(s1.charAt(i) - '0');

        Result res = divide(A, b);
        for (int digit : res.quotient) System.out.print(digit);
        System.out.println("\n余数：" + res.remainder);
    }
}

4.高精度乘低精度

import java.util.*;

public class HighPrecisionMultiplicationLow {
   
   
    public static List<Integer> multiply(List<Integer> A, int b) {
   
   
        List<Integer> C = new ArrayList<>();
        int t = 0;
        for (int digit : A) {
   
   
            t += digit * b;
            C.add(t % 10);
            t /= 10;