排座椅

import java.util.*;
import java.io.*;
import java.util.stream.Collectors;

//横向只能分割上下相邻，纵向只能分割左右相邻
//遍历相邻同学对，统计横向或纵向的某条线各能隔开多少同学。
//选择符合题意的最多横向和纵向同学
public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        int[] line1 = Arrays.stream(bf.readLine().split(" ")).mapToInt(
                          Integer::parseInt).toArray();
        //分别统计行和列的整数
        TreeMap<Integer, Integer> tr = new TreeMap<>();
        TreeMap<Integer, Integer> tc = new TreeMap<>();

        for (int i = 1; i <= line1[4]; i++) {
            String[] pair = bf.readLine().split(" ");
            if (pair[1].equals(pair[3])) {
                int row = Math.min(Integer.parseInt(pair[0]), Integer.parseInt(pair[2]));
                tr.put(row, tr.getOrDefault(row, 0) + 1);
            } else {
                int col = Math.min(Integer.parseInt(pair[1]), Integer.parseInt(pair[3]));
                tc.put(col, tc.getOrDefault(col, 0) + 1);
            }
        }
        StringJoiner sj = new StringJoiner(" ");
        Map<Integer, Integer> Desc1 = tr.entrySet().stream()
                                      .sorted(Map.Entry.<Integer, Integer>comparingByValue().reversed()) // 降序排序
                                      .collect(Collectors.toMap(
                                              Map.Entry::getKey,
                                              Map.Entry::getValue,
                                              (e1, e2) -> e1, // 处理键冲突（此处无冲突）
                                              LinkedHashMap::new // 保持排序后的顺序
                                               ));
        int i = 0, j = 0;
        //收集到sj中进行然后再次用比较器排序
        for (Map.Entry<Integer, Integer> entry : Desc1.entrySet()) {
            if (i < line1[2]) {
                sj.add(entry.getKey().toString());
            } else {
                break;
            }
            i++;
        }
        String[] res = sj.toString().split(" ");
        Arrays.sort(res,(a,b)->Integer.parseInt(a)-Integer.parseInt(b));
        System.out.println(String.join(" ", res));
        Map<Integer, Integer> Desc2 = tc.entrySet().stream()
                                      .sorted(Map.Entry.<Integer, Integer>comparingByValue().reversed()) // 降序排序
                                      .collect(Collectors.toMap(
                                              Map.Entry::getKey,
                                              Map.Entry::getValue,
                                              (e1, e2) -> e1, // 处理键冲突（此处无冲突）
                                              LinkedHashMap::new // 保持排序后的顺序
                                               ));
        sj = new StringJoiner(" ");
        for (Map.Entry<Integer, Integer> entry : Desc2.entrySet()) {
            if (j < line1[3]) {
                sj.add(entry.getKey().toString());
            } else {
                break;
            }
            j++;
        }
        res = sj.toString().split(" ");
        Arrays.sort(res,(a,b)->Integer.parseInt(a)-Integer.parseInt(b));
        System.out.println(String.join(" ", res));
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 行数
        int m = sc.nextInt(); // 列数
        int k = sc.nextInt(); // 横向通道数量
        int l = sc.nextInt(); // 纵向通道数量
        int d = sc.nextInt(); // 交头接耳的对数

        // 统计每个横向通道能隔开的对数
        int[] horizontal = new int[n];
        // 统计每个纵向通道能隔开的对数
        int[] vertical = new int[m];

        for (int i = 0; i < d; i++) {
            int x1 = sc.nextInt();
            int y1 = sc.nextInt();
            int x2 = sc.nextInt();
            int y2 = sc.nextInt();

            if (x1 == x2) {
                // 左右相邻，属于纵向通道
                int col = Math.min(y1, y2);
                vertical[col]++;
            } else {
                // 上下相邻，属于横向通道
                int row = Math.min(x1, x2);
                horizontal[row]++;
            }
        }

        // 选择最优的横向通道
        List<Integer> hList = new ArrayList<>();
        for (int i = 1; i < n; i++) {
            hList.add(i);
        }
        // 按重要性降序排序，重要性相同则按位置升序
        Collections.sort(hList, (a, b) -> {
            if (horizontal[a] != horizontal[b]) {
                return Integer.compare(horizontal[b], horizontal[a]);
            } else {
                return Integer.compare(a, b);
            }
        });
        // 取前k个并排序
        List<Integer> hResult = hList.subList(0, k);
        Collections.sort(hResult);

        // 选择最优的纵向通道
        List<Integer> vList = new ArrayList<>();
        for (int i = 1; i < m; i++) {
            vList.add(i);
        }
        // 按重要性降序排序，重要性相同则按位置升序
        Collections.sort(vList, (a, b) -> {
            if (vertical[a] != vertical[b]) {
                return Integer.compare(vertical[b], vertical[a]);
            } else {
                return Integer.compare(a, b);
            }
        });
        // 取前l个并排序
        List<Integer> vResult = vList.subList(0, l);
        Collections.sort(vResult);

        // 输出横向通道
        for (int i = 0; i < hResult.size(); i++) {
            if (i > 0) {
                System.out.print(" ");
            }
            System.out.print(hResult.get(i));
        }
        System.out.println();

        // 输出纵向通道
        for (int i = 0; i < vResult.size(); i++) {
            if (i > 0) {
                System.out.print(" ");
            }
            System.out.print(vResult.get(i));
        }
        System.out.println();
    }
}