华为OD机试 - 最少数量线段覆盖 - 二叉树（Java 2023 B卷 100分考试抽中题）

news2024/9/24 7:25:45

在这里插入图片描述

一、题目描述

给定坐标轴上的一组线段，线段的起点和终点均为整数并且长度不小于1，请你从中找到最少数量的线段，这些线段可以覆盖住所有线段。

二、输入描述

第一行输入为所有线段的数量，不超过10000，后面每行表示一条线段，格式为"x,y"，x和y分别表示起点和终点，取值范围是[-105,105]。

三、输出描述

最少线段数量，为正整数。

四、解题思路

定义一个节点，有左节点和右节点两个属性；
在Node类中定义compareTo方法，比较Node左节点；
- 如果当前node和参数node的左节点相当，返回参数右节点与当前的右节点差；
- 如果当前node和参数node的左节点不相当，返回当前node和参数node的左节点的差值；
输入所有线段的数量n；
输入n个Node节点，有两个值，起点和终点；
将输入的Node节点进行排序，根据Node左节点进行升序排列；
定义变量right，记录第一个节点的右节点；
定义变量maxRight，记录最大右节点，初始化为第一个节点的右节点；
遍历节点集合arr；
如果之后的右节点大于第一个右节点；
比较最大右节点与当前的右节点；
获取最大右节点；
循环往复，最后输出最少线段数量。

四、Java算法源码

public static void main(String[] args) {
    Node[] arr = new Node[10000];
    Scanner sc = new Scanner(System.in);
    // 输入所有线段的数量n
    int n = sc.nextInt();
    // 输入n个Node节点，有两个值，起点和终点
    for (int i = 0; i < n; i++) {
        String[] s = sc.next().split(",");
        arr[i] = new Node(Integer.parseInt(s[0]), Integer.parseInt(s[1]));
    }
    
    // 将输入的Node节点进行排序，根据Node左节点进行升序排列
    Arrays.sort(arr, 0, n - 1);

    int ret = 1;
    // 第一个节点的右节点
    int right = arr[0].r;
    // 最大右节点，初始化为第一个节点的右节点
    int maxRight = arr[0].r;
    for (int i = 1; i < n; i++) {
        // 如果之后的右节点大于第一个右节点
        if (arr[i].l > right) {
            // 比较最大右节点与当前的右节点
            if (maxRight > right) {
                ret++;
                right = maxRight;
            }
            if (maxRight < arr[i].l) {
                ret++;
                right = arr[i].r;
            }
        }
        // 获取最大右节点
        maxRight = Math.max(arr[i].r, maxRight);
    }
    if (maxRight > right) {
        ret++;
    }
    System.out.println(ret);
}

/**
 * 定义一个节点，有左节点和右节点两个属性
 */
static class Node implements Comparable<Node> {
    int l, r;

    public Node(int l, int r) {
        this.l = l;
        this.r = r;
    }

    /**
     * 和当前结点进行比较
     * 如果当前node和参数node的左节点相当，返回参数右节点与当前的右节点差
     * 如果当前node和参数node的左节点不相当，返回当前node和参数node的左节点的差值
     * @param o
     * @return
     */
    @Override
    public int compareTo(Node o) {
        if (l == o.l) {
            return o.r - r;
        }
        return l - o.l;
    }
}