华为OD技术C卷“测试用例执行计划”Java解答

描述

示例

算法思路1

整体思路是，先读取特性的优先级和测试用例覆盖的特性列表，然后计算每个测试用例的优先级，并将其与测试用例的索引存储到二维数组中。最后按照优先级和索引排序，输出测试用例的索引，即为执行顺序。 

1. 首先从标准输入中读取了两个整数 n 和 m，分别表示特性的数量和测试用例的数量。

2. 创建了一个长度为 n 的数组 priorities，用于存储特性的优先级。

3. 使用循环读取每个特性的优先级，并将其存储到 priorities 数组中。

4. 通过 in.nextLine() 读取了一个空行，用于消耗掉换行符。

5. 创建了一个二维数组 res，其行数为测试用例的数量 m，列数为2，用于存储测试用例的优先级和对应的索引。

6. 使用循环遍历每个测试用例：

   • 使用 in.nextLine() 读取了一行输入，其中包含了一个测试用例覆盖的特性列表。
   • 使用 split(" ") 方法将输入拆分为特性的索引数组。
   • 使用流式处理将特性的索引转换为整数流，并对每个特性索引计算其对应特性的优先级，并将所有特性的优先级求和。
   • 将求和得到的优先级和当前测试用例的索引存储到 res 数组中。

7. 使用 Arrays.sort() 对 res 数组进行排序，排序规则为：

   • 首先按照测试用例的优先级从大到小排序。
   • 如果测试用例的优先级相同，则按照测试用例的索引从小到大排序。

8. 使用循环遍历排序后的 res 数组，并输出测试用例的索引（ID），注意索引从0开始，需要加1。

答案1

import java.util.Arrays;
import java.util.Scanner;
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
// 注意 hasNext 和 hasNextLine 的区别
        int n = in.nextInt();
        int m = in.nextInt();
        int[] priorities = new int[n];
        for (int i = 0; i < n; i++) {
            priorities[i] = in.nextInt();
        }
        in.nextLine();
        int[][] res = new int[m][2];
        for (int i = 0; i < m; i++) {
            int sum = Arrays.stream(in.nextLine().split(" ")).mapToInt(a -> {
                int idx = Integer.parseInt(a);
                return priorities[idx - 1];
            }).sum();
            res[i][0] = sum;
            res[i][1] = i;
        }
        Arrays.sort(res, (a,b) -> {
            return b[0]-a[0] == 0 ? a[1] - b[1] : b[0]-a[0];
        });
        for (int[] re : res) {
            System.out.println(re[1]+1);
        }
    }
}

详解1

int sum = Arrays.stream(in.nextLine().split(" ")).mapToInt(a -> { int idx = Integer.parseInt(a); return priorities[idx - 1]; }).sum(); 

1. in.nextLine() 用来读取一行输入。这行输入是一系列用空格分隔的整数，表示任务的优先级索引。

2. .split(" ") 将读取到的一行输入按照空格进行分割，将每个优先级索引分开，形成一个字符串数组。

3. Arrays.stream() 将得到的字符串数组转换为一个流（Stream），这样我们就可以对每个优先级索引进行操作。

4. .mapToInt(a -> {...}) 这是一个映射操作，对流中的每个元素进行处理。对于每个优先级索引 a，执行一系列操作：

   a. int idx = Integer.parseInt(a); 将字符串表示的优先级索引转换为整数。

   b. priorities[idx - 1] 通过索引找到对应的优先级，并返回。

5. .sum() 对映射后的优先级数组求和，得到该任务的总优先级。

整体来说，这段代码的作用是将每个任务的优先级索引转换为对应的优先级，然后计算总优先级，最后将这些总优先级存储在 sum 变量中。 

Arrays.sort(res, (a,b) -> {
    return b[0]-a[0] == 0 ? a[1] - b[1] : b[0]-a[0];
}); 

这段代码使用了一个 lambda 表达式作为比较器，用于比较二维数组 res 中的元素。Lambda 表达式的参数是 (a, b)，其中 a 和 b 是 res 中的每个元素，类型为 int[]。Lambda 表达式的主体根据总优先级和任务索引的比较结果返回一个整数值，用于指示元素的相对顺序。

Lambda 表达式中的逻辑解释如下：

• b[0]-a[0] == 0：首先，按照元素的第一个值（即总优先级）进行比较。如果两个元素的总优先级相等，则进入三元条件运算符的条件部分。

• a[1] - b[1]：如果两个元素的总优先级相等，则按照元素的第二个值（即任务索引）进行比较。这部分逻辑会在总优先级相等时生效，以确保相同优先级的任务按照索引升序排列。

• b[0]-a[0]：如果两个元素的总优先级不相等，则直接根据总优先级的差值返回比较结果，以便在排序时按照总优先级降序排列。

Lambda表达式应用 

Lambda表达式是Java编程语言中引入的一种函数式编程特性。它提供了一种简洁的语法来创建匿名函数，从而更轻松地实现函数式编程风格的代码。Lambda表达式通常用于替代匿名内部类的简单情况，使代码更加简洁和易读。

Lambda表达式的一般语法如下：

(parameters) -> expression

或者

(parameters) -> { statements; }

Lambda表达式由几个部分组成：

1. 参数列表：表示Lambda表达式接受的参数。如果没有参数，可以留空或使用一对空括号 ()。
2. 箭头 ->：将参数列表和Lambda表达式的主体分隔开来。
3. 主体：可以是一个表达式，也可以是一段代码块。如果是一个表达式，它的结果将作为Lambda表达式的返回值。如果是一段代码块，则需要使用大括号 {} 将代码块括起来，并且需要使用 return 关键字来返回值。

Lambda表达式的特点包括：

• 简洁性：Lambda表达式使用了一种简洁的语法，可以使代码更加简洁、易读。
• 匿名性：Lambda表达式可以创建匿名函数，无需显式地命名函数。
• 类型推断：Java编译器可以推断Lambda表达式的参数类型，使得Lambda表达式的使用更加方便。
• 语法灵活性：Lambda表达式可以用于函数式接口，使得在需要函数式接口的地方可以使用Lambda表达式代替传统的匿名内部类。

Lambda表达式详见Lambda表达式-CSDN博客

Stream流待更新……

算法思路2

1. 读取输入并保存数据结构：

   • 读取特性的数量 N 和测试用例的数量 M。
   • 创建一个长度为 N 的数组，用于存储特性的优先级。
   • 创建一个长度为 M 的列表，其中每个元素是一个集合，表示每个测试用例覆盖的特性。

2. 计算测试用例的优先级：

   • 遍历测试用例列表，对于每个测试用例，遍历其覆盖的特性集合，累加特性的优先级，得到测试用例的优先级。

3. 按照规则排序测试用例：

   • 对测试用例列表进行排序，首先按照优先级从大到小排序，如果优先级相同，则按照测试用例的ID从小到大排序。

4. 输出测试用例的执行顺序：

   • 按照排序后的顺序输出测试用例的ID。

答案2

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt(); // 特性的数量
        int M = scanner.nextInt(); // 测试用例的数量

        int[] priorities = new int[N + 1]; // 特性的优先级，索引从1开始
        for (int i = 1; i <= N; i++) {
            priorities[i] = scanner.nextInt();
        }
        scanner.nextLine(); // 消耗换行符
        List<TestCase> testCases = new ArrayList<>();
        for (int i = 1; i <= M; i++) {
            int priority = 0;
            String[] features = scanner.nextLine().split(" ");
            for (String feature : features) {
                int featureId = Integer.parseInt(feature);
                priority += priorities[featureId];
            }
            testCases.add(new TestCase(i, priority));
        }

        // 按照优先级从大到小排序，如果优先级相同则按照ID从小到大排序
        testCases.sort((a, b) -> a.priority != b.priority ? Integer.compare(b.priority, a.priority) : Integer.compare(a.id, b.id));

        // 输出测试用例的执行顺序
        for (TestCase testCase : testCases) {
            System.out.println(testCase.id);
        }

        scanner.close();
    }

    static class TestCase {
        int id; // 测试用例的ID
        int priority; // 测试用例的优先级

        public TestCase(int id, int priority) {
            this.id = id;
            this.priority = priority;
        }
    }
}

详解2

list列表接口的使用详见Java“集合框架”知识速成笔记学完就去实战（三）-CSDN博客文章浏览阅读1.1k次，点赞32次，收藏12次。吐血整理！本文为Java中集合类型的一些常见接口和实现类，包括List接口，Set接口和Map接口，重点介绍了HashSet实现类。https://blog.csdn.net/wwwwwmmn/article/details/136433958