华为OD2023(A卷)基础题25【端口合并】

题目描述

有M个端口组(1<=M<=10)，
每个端口组是长度为N的整数数组(1<=N<=100)，
如果端口组间存在2个及以上不同端口相同，则认为这2个端口组互相关联，可以合并。

输入描述

第一行输入端口组个数M，再输入M行，每行逗号分割，代表端口组。

备注：端口组内数字可以重复。

输出描述

输出合并后的端口组，用二维数组表示。

组内相同端口仅保留一个，从小到达排序。
组外顺序保持输入顺序
备注：M,N不在限定范围内，统一输出一组空数组[[]]

用例

输入
4
4
2,3,2
1,2
5
输出
[[4],[2,3],[1,2],[5]]
说明
仅有一个端口2相同，不可以合并。

输入
3
2,3,1
4,3,2
5
输出
[[1,2,3,4],[5]]
说明
无

输入
6
10
4,2,1
9
3,6,9,2
6,3,4
8
输出
[[10],[1,2,3,4,6,9],[9],[8]]
说明
无

import java.util.*;

/**
 * 
 * 
 * 首先，在 `main` 方法中从标准输入读入一个整数 `m`，表示有几组端口列表。然后，利用一个二维列表 `ports` 
 * 存储每一组端口列表，其中每个子列表存储一个端口列表。接着，对每一组端口列表进行处理，将其分隔为整数列表，
 * 并将处理后的结果加入到 `ports` 列表中。如果发现有空的端口列表或者大于100个端口的列表，就输出 `[[]]`；
 * 否则，调用 `getResult` 方法得到最终的端口列表结果，并去掉其中的空白字符后输出。
 *
 * 在 `getResult` 方法中，采用了迭代的方式不断对端口列表进行合并，直到不能再合并为止。
 * 具体实现中，使用 `forPorts` 方法判断是否能够合并，如果可以就将后面的端口组并入前面的端口组，然后返回 `true`。
 * 否则，返回 `false`，表示不能再合并了。另外，还定义了一个 `distinctAndSort` 方法，
 * 用于对一个端口列表进行去重并排序的操作。
 *
 * 最后，利用 StringBuilder 组装输出字符串。遍历每个端口列表，将去重并排序后的结果转为字符串，
 * 并加入到 StringBuilder 中。最后，在输出前判断最后一个字符是否为逗号，如果是，则删除它，然后在字符串末尾加上 "]"，
 * 得到最终的结果字符串。
 */
public class OdAb25 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        List<List<Integer>> ports = new ArrayList<>();
        for (int i = 0; i < m; i++) {
            String input = scanner.next(); // 将访问号分隔的字符串转为整列表
            List<Integer> portList = new ArrayList<>();
            for (String portStr : input.split(",")) { // 分隔字符串
                portList.add(Integer.parseInt(portStr)); // 将字符串转为整数后加入端口列表
            }
            ports.add(portList); // 将端口列表加入二维列表中
        }
        if (ports.stream().anyMatch(p -> p.size() < 1 || p.size() > 100)) { // 判断是否有空的端口列表或者大于100个端口的列表
            System.out.println("[[]]");
        } else {
            System.out.println(getResult(ports).replaceAll("\\s", "")); // 输出端口列表的结果，去掉空白字符
        }
    }

    private static boolean canUnion(List<Integer> port1, List<Integer> port2) {
        // 判断两个端口列表是否可以合并
        port1.sort(Integer::compareTo); // 对端口列表进行排序
        port2.sort(Integer::compareTo);
        int same = 0; // 相同的端口数量
        int i = 0, j = 0;
        while (i < port1.size() && j < port2.size()) {
            if (port1.get(i).equals(port2.get(j))) { // 如果两个端口相同
                i++;
                j++;
                same++; // 记录相同的端口数量
                if (same >= 2) { // 如果有两个以上的相同端口，说明可以合并
                    return true;
                }
            } else if (port1.get(i) > port2.get(j)) { // 如果第一个列表当前位置大于第二个列表当前位置，就将第二个列表向后移动一位
                j++;
            } else {
                i++; // 否则将第一个列表向后移动一位
            }
        }
        return false; // 如果不能合并，返回false
    }

    private static boolean forPorts(List<List<Integer>> ports) {
        // 倒序遍历端口列表，保证组外顺序保持输入顺序
        for (int i = ports.size() - 1; i >= 0; i--) {
            for (int j = i - 1; j >= 0; j--) {
                // 判断两个端口是否可以合并
                if (canUnion(ports.get(i), ports.get(j))) { // 如果可以合并
                    // 将后面的端口组并入前面的端口组
                    ports.get(j).addAll(ports.get(i));
                    ports.remove(i);
                    return true;
                }
            }
        }
        return false; // 如果不能合并，返回false
    }

    private static List<Integer> distinctAndSort(List<Integer> port) {
        // 去重并排序
        List<Integer> tmp = new ArrayList<>(port); // 创建中间列表存储处理后的结果
        tmp.sort(Integer::compareTo); // 对列表进行排序
        for (int i = tmp.size() - 1; i > 0; i--) {
            if (tmp.get(i).equals(tmp.get(i - 1))) { // 如果当前端口和前一个端口相同，就将当前端口从列表中删除
                tmp.remove(i);
            }
        }
        return tmp; // 返回去重并排序后的端口列表
    }

    private static String getResult(List<List<Integer>> ports) {
        while (true) {
            if (!forPorts(ports)) { // 如果不能合并了，退出循环
                break;
            }
        }
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (List<Integer> port : ports) { // 遍历二维列表中的每个端口列表
            sb.append(distinctAndSort(port)).append(","); // 将去重并排序后的端口列表转为字符串加入StringBuilder中
        }
        if (sb.charAt(sb.length() - 1) == ',') { // 如果字符符串最后一个字符符是访问号，就删除
            sb.deleteCharAt(sb.length() - 1);
        }
        // 在字符串末端添加上 "]"
        sb.append("]");
        // 返回最后的结果字符串
        return sb.toString();
    }
}