PriorityQueue + 矩阵转置 + 矩阵压缩

import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 998244353
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        int a = sc.nextInt();
        int b = sc.nextInt();
        int[][] matrix = new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                matrix[i][j] = sc.nextInt();
            }
        }

        int[][] arrMax = getZip(matrix, matrix.length, matrix[0].length - b + 1, b, true);
//        for (int i = 0; i < arrMax.length; i++) System.out.println(Arrays.toString(arrMax[i]));
//        System.out.println("------------------------------------------------------------------");

        matrix = transpose(matrix);
        int[][] arrMin = getZip(matrix, matrix.length, matrix[0].length - a + 1, a, false);
        arrMin = transpose(arrMin);
//        for (int i = 0; i < arrMin.length; i++) System.out.println(Arrays.toString(arrMin[i]));
//        System.out.println("------------------------------------------------------------------");

        arrMax = transpose(arrMax);
        arrMax = getZip(arrMax, arrMax.length, arrMax[0].length - a + 1, a, true);
        arrMax = transpose(arrMax);
//        for (int i = 0; i < arrMax.length; i++) System.out.println(Arrays.toString(arrMax[i]));
//        System.out.println("------------------------------------------------------------------");


        arrMin = getZip(arrMin, arrMin.length, arrMin[0].length - b + 1, b, false);
//        for (int i = 0; i < arrMin.length; i++) System.out.println(Arrays.toString(arrMin[i]));
//        System.out.println("------------------------------------------------------------------");

        int ans = 0;
        for (int i = 0; i < arrMax.length; i++) {
            for (int j = 0; j < arrMax[0].length; j++) {
                ans += arrMax[i][j] * arrMin[i][j];
            }
        }

        System.out.println(ans);

    }

    // 矩阵转置
    public static int[][] transpose(int[][] matrix) {
        int rows = matrix.length;
        int cols = matrix[0].length;

        int[][] transposedMatrix = new int[cols][rows];

        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                transposedMatrix[j][i] = matrix[i][j];
            }
        }

        return transposedMatrix;
    }

    // 压缩矩阵
    public static int[][] getZip(int[][] matrix, int n, int m, int a, boolean flag) {
        int[][] ans = new int[n][m];
        for (int i = 0; i < matrix.length; i++) {
            PriorityQueue<Integer> queue;
            queue = flag ? new PriorityQueue<>(Collections.reverseOrder()) : new PriorityQueue<>();
            int col = 0;
            for (int j = 0; j < matrix[0].length; j++) {
                queue.add(matrix[i][j]);
                if (queue.size() == a) {
                    ans[i][col] = queue.peek();
                    queue.remove(matrix[i][col]);
                    col++;
                }
            }
        }
        return ans;
    }

}