华为OD机试 - 高效的任务规划 - 逻辑分析（Java 2023 B卷 200分）

news2024/11/26 16:53:11

在这里插入图片描述

专栏导读

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

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

一、题目描述

你有 n 台机器，编号为 1~n，每台都需要完成一项工作，机器经过配置后都能完成独立完成一项工作。

假设第 i 台机器你需要花 B 分钟进行设置，然后开始运行，J 分钟后完成任务。

现在，你需要选择布置工作的顺序，使得用最短的时间完成所有工作。

注意，不能同时对两台进行配置，但配置完成的机器们可以同时执行他们各自的工作。

二、输入描述

第一行输入代表总共有 M 组任务数据 (1<M<=10)。

每组数第一行为一个整数指定机器的数量 N (0<N<=1000)。

随后的 N 行每行两个整数，第一个表示 B (0<=B<=10000)，第二个表示 J (0<=J<=10000)

每组数据连续输入，不会用空行分隔。各组任务单独计时。

三、输出描述

对于每组任务，输出最短完成时间，且每组的结果独占一行。

四、解题思路

题意要求：

不能同时对两台进行设置，并且输出最短完成时间。

理解为：

执行时间越长的机器，越先设置，完成时间越短；
如果执行时间相等，设置时间越短，就会越先执行，完成时间越短；
当前机器的执行时间如果大于后面所有机器的设置时间，得到额外执行时间；
再对所有机器的额外执行时间进行比较，取最大值，再加上所有设置时间，即总运行时间；

五、Java算法源码

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    // m组任务
    int m = Integer.valueOf(sc.nextLine());
    StringJoiner stringJoiner = new StringJoiner("\n");
    for (int i = 0; i < m; i++) {
        // n台机器
        int n = Integer.valueOf(sc.nextLine());
        List<String> list = new ArrayList<>();
        for (int j = 0; j < n; j++) {
            list.add(sc.nextLine());
        }

        // 总设置时长
        int allSetTime = 0;

        /**
         * 不能同时对两台进行设置，并且 输出最短完成时间
         * 执行时间越长的机器，越先设置，完成时间越短
         * 如果执行时间相等，设置时间越短，就会越先执行，完成时间越短
         */
        List<String> sortList = list.stream().sorted(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                String[] arr1 = o1.split(" ");
                String[] arr2 = o2.split(" ");
                if (arr1[1].equals(arr2[1])) {
                    return arr1[0].compareTo(arr2[0]);
                } else {
                    return arr2[1].compareTo(arr1[1]);
                }
            }
        }).collect(Collectors.toList());
        System.out.println(list);
        System.out.println(sortList);

        /**
         * 当前机器的执行时间如果大于后面所有机器的设置时间，得到额外执行时间
         * 再对所有机器的额外执行时间进行比较，取最大值，再加上所有设置时间，即总运行时间
         *
         * [2 3, 4 3, 1 1]
         * [2 3, 4 3, 1 1]
         * 设置2，执行3  剩余执行3   设置4，执行3  剩余执行3     设置1，执行1   剩余最大执行2
         * 2                          +  4                       +1                +2   = 9
         */
        int[] runLeftTimeArr = new int[n];
        for (int j = 0; j < sortList.size(); j++) {
            String[] temp = sortList.get(j).split(" ");
            Integer currentSetTime = Integer.valueOf(temp[0]);
            // 当前机器的执行时间
            Integer currentRunTime = Integer.valueOf(temp[1]);
            // 总设置时长
            allSetTime += currentSetTime;

            for (int k = 0; k < j; k++) {
                if (runLeftTimeArr[k] > 0) {
                    runLeftTimeArr[k] -= currentSetTime;
                }
            }
            runLeftTimeArr[j] = currentRunTime;
        }

        int runLeftMax = 0;
        for (int j = 0; j < runLeftTimeArr.length; j++) {
            if (runLeftTimeArr[j] > runLeftMax) {
                runLeftMax = runLeftTimeArr[j];
            }
        }
        stringJoiner.add(allSetTime + runLeftMax+"");
    }
    System.out.println(stringJoiner);
}

六、效果展示

1、输入

1
3
1 1
4 3
2 3

2、输出

3、说明

先按执行时间降序排序，[4 3, 2 3, 1 1]；
如果执行时间相同，再按设置时间升序排序，[2 3, 4 3, 1 1]；

[2 3, 4 3, 1 1]
设置2，执行3  剩余执行3   设置4，执行3  剩余执行3     设置1，执行1   剩余最大执行2
2                          +  4                       +1                +2   = 9