华为OD机试 - 最少面试官数 - 深度优先搜索dfs（Java 2023 B卷 200分）

news2024/10/1 15:23:10

在这里插入图片描述

- 专栏导读
- 一、题目描述
- 二、输入描述
- 三、输出描述
- - 1、输入
  - 2、输出
  - 3、说明
- 四、解题思路
- - 1、核心思路：
  - 2、具体步骤
- 五、Java算法源码
- 六、效果展示
- - 1、输入
  - - 按照面试的开始时间升序排序，如果开始时间相同，按照结束时间的升序排序
  - 2、输出
  - 3、说明

华为OD机试 2023B卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试（JAVA）真题（A卷+B卷）》。

刷的越多，抽中的概率越大，每一题都有详细的答题思路、详细的代码注释、样例测试，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

某公司组织一场公开招聘活动，假设由于人数和场地的限制，每人每次面试的时长不等，并已经安排给定，用(S1,E1)、(S2,E2)(Sj,Ej)…(Si< Ei，均为非负整数)表示每场面试的开始和结束时间。

面试采用一对一的方式，即一名面试官同时只能面试一名应试者，一名面试官完成一次面试后可以立即进行下一场面试，且每个面试官的面试人次不超过 m。为了支撑招聘活动高效顺利进行，请你计算至少需要多少名面试官。

二、输入描述

输入的第一行为面试官的最多面试人次 m，第二行为当天总的面试场次 n

接下来的 n 行为每场面试的起始时间和结束时间，起始时间和结束时间用空格分隔.

其中，1 <= n,m <= 500

三、输出描述

输出一个整数，表示至少需要的面试官数量。

1、输入

2 4
8 10
11 13
10 12
12 13

2、输出

3、说明

第一个面试官，面试第一场8 10、第三场10 12
第二个面试官，面试第二场11 13
第三个面试官，面试第四场12 13

四、解题思路

1、核心思路：

寻找每一位面试官可以面试的符合要求的所有场次。

2、具体步骤

输入一个面试官的最多面试人次m，当天总的面试场次n；
接下来的n行输入面试起始时间和结束时间，将其加入arrList；
按照面试的开始时间升序排序，如果开始时间相同，按照结束时间的升序排序；
深度优先搜索，获取面试官数量；
- 搜索完所有面试，即结束；
- 获取当前面试官的最新一次面试preArr；
- 当前面试官，面试次数+1；
- 遍历其余场次，如果下一场符合要求；
  - 如果下一场符合要求；
  - 当前面试官，面试次数+1；
  - 因为remove的原因，i-1；
  - 重置当前面试官的最新一次面试；
- 如何当前时间不符合面试官要求，则比较下一场；
搜索完当前面试官后，面试官数量+1
寻找下一个面试官合适的面试场次；
最后输出面试官数量sum。

五、Java算法源码

public class OdTest {
    // 一个面试官的最多面试人次
    static int m = 0;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] input = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        // 一个面试官的最多面试人次
        m = input[0];
        // 当天总的面试场次
        int n = input[1];

        // 每场面试的时间集合
        List<Integer[]> arrList = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            Integer[] arr = Arrays.stream(sc.nextLine().split(" ")).map(Integer::valueOf).toArray(Integer[]::new);
            arrList.add(arr);
        }

        // 按照面试的开始时间升序排序，如果开始时间相同，按照结束时间的升序排序
        Collections.sort(arrList, new Comparator<Integer[]>() {
            @Override
            public int compare(Integer[] o1, Integer[] o2) {
                if(o1[0] > o2[0]){
                    return 1;
                }else if(o1[0] < o2[0]){
                    return -1;
                }else{
                    if(o1[1] > o2[1]){
                        return 1;
                    }else if(o1[1] < o2[1]){
                        return -1;
                    }else {
                        return 0;
                    }
                }
            }
        });

        // 深度优先搜索，获取面试官数量
        dfs(arrList);

        System.out.println(sum);
    }

    // 面试官数量
    static int sum = 0;
    // 一个面试官的面试次数
    static int times = 0;

    private static void dfs(List<Integer[]> arrList){
        // 搜索完所有面试，即结束
        if(arrList.size() == 0){
            return;
        }

        // 当前面试官的最新一次面试
        Integer[] preArr = arrList.get(0);
        arrList.remove(0);
        System.out.println("第"+(sum+1)+"位面试官，面试的场次："+preArr[0] + " " + preArr[1]);
        // 当前面试官，面试次数+1
        times++;
        for (int i = 0; i < arrList.size(); i++) {
            // 一个面试官的最多面试人次
            if(times == m){
                times = 0;
                break;
            }

            Integer[] nextArr = arrList.get(i);
            if(preArr[1] <= nextArr[0]){
                arrList.remove(i);
                // 当前面试官，面试次数+1
                times++;
                // 因为remove的原因，i-1
                i--;
                // 重置当前面试官的最新一次面试
                preArr = nextArr;
                System.out.println("第"+(sum+1)+"位面试官，面试的场次："+preArr[0] + " " + preArr[1]);
            }else{
                // 如何当前时间不符合面试官要求，则比较下一场
                continue;
            }
        }

        // 面试官数量+1
        sum++;
        // 下一个面试官面试场次归0
        times = 0;
        // 寻找下一个面试官合适的面试场次
        dfs(arrList);
    }
}