返回目录

题目描述

某个产品当前迭代周期内有 N 个特性（F1,F2,…FN）需要进行覆盖测试，每个特性都被评估了对应的优先级，特性使用其 ID 作为下标进行标识。

设计了 M 个测试用例（T1,T2,…,TM），每个测试用例对应一个覆盖特性的集合，测试用例使用其 ID 作为下标进行标识，测试用例的优先级定义为其覆盖的特性的优先级之和。

在开展测试之前，需要制定测试用例的执行顺序，规则为：优先级大的用例先执行，如果存在优先级相同的用例，用例 ID 小的先执行。

输入描述

第一行输入为 N 和 M，

• N 表示特性的数量，0 < N ≤ 100
• M 表示测试用例的数量，0 < M ≤ 100

之后 N 行表示特性 ID=1 到特性 ID=N 的优先级，

再接下来 M 行表示测试用例 ID=1 到测试用例 ID=M 关联的特性的 ID 的列表。

输出描述

按照执行顺序（优先级从大到小）输出测试用例的 ID，每行一个ID。

测试用例覆盖的 ID 不重复。

示例：

解题思路

这道题看懂题目就会做了！！！

用例1包含了5个特性和4个测试用例，具体如下：

1. 特性优先级列表：

   • 特性1的优先级为1
   • 特性2的优先级为1
   • 特性3的优先级为2
   • 特性4的优先级为3
   • 特性5的优先级为5

2. 测试用例及其涉及的特性：

   • 测试用例1涉及的特性为1, 2, 3
   • 测试用例2涉及的特性为1, 4
   • 测试用例3涉及的特性为3, 4, 5
   • 测试用例4涉及的特性为2, 3, 4

接下来解释每个测试用例的优先级计算和排序：

• 测试用例1的优先级计算：特性1 + 特性2 + 特性3 = 1 + 1 + 2 = 4
• 测试用例2的优先级计算：特性1 + 特性4 = 1 + 3 = 4
• 测试用例3的优先级计算：特性3 + 特性4 + 特性5 = 2 + 3 + 5 = 10
• 测试用例4的优先级计算：特性2 + 特性3 + 特性4 = 1 + 2 + 3 = 6

根据这些计算，测试用例按照优先级从高到低排列为：测试用例3, 测试用例4, 测试用例1, 测试用例2。如果有优先级相同的情况，则按照测试用例的ID升序排列。在这个例子中，测试用例1和测试用例2的优先级相同，因此按照ID顺序排列。最终的排序结果是：

1. 测试用例3
2. 测试用例4
3. 测试用例1
4. 测试用例2

Python算法源码

# 定义一个测试用例类
class TestCase:
    def __init__(self, id, priority):
        self.id = id  # 测试用例的ID
        self.priority = priority  # 测试用例的优先级

# 主函数
def main():
    # 读取输入的N和M，分别代表特性数量和测试用例数量
    N, M = map(int, input().split())

    # 存储每个特性的优先级
    feature_priorities = [int(input()) for _ in range(N)]

    # 处理每个测试用例
    test_cases = []
    for i in range(M):
        # 读取并解析每个测试用例涉及的特性ID列表
        features = list(map(int, input().split()))
        priority_sum = sum(feature_priorities[feature - 1] for feature in features[1:])  # 计算测试用例的总优先级
        # 创建测试用例对象，并存储ID和计算得到的优先级
        test_cases.append(TestCase(i + 1, priority_sum))

    # 对测试用例根据优先级进行排序
    test_cases.sort(key=lambda x: (-x.priority, x.id))  # 优先级降序排列，ID升序排列

    # 输出按优先级排序后的测试用例ID
    for test_case in test_cases:
        print(test_case.id)

# 调用主函数
if __name__ == "__main__":
    main()

C算法源码

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int id; // 测试用例的ID
    int priority; // 测试用例的优先级
} TestCase;

// 比较函数，用于qsort排序
int compare(const void *a, const void *b) {
    TestCase *testCaseA = (TestCase *)a;
    TestCase *testCaseB = (TestCase *)b;

    // 首先按照优先级降序排序
    if (testCaseA->priority != testCaseB->priority) {
        return testCaseB->priority - testCaseA->priority;
    } else {
        // 如果优先级相同，则按照ID升序排序
        return testCaseA->id - testCaseB->id;
    }
}

int main() {
    int N, M;
    scanf("%d %d", &N, &M); // 读取N和M的值

    // 动态分配存储特性优先级的数组
    int *featurePriorities = (int *)malloc(N * sizeof(int));
    for (int i = 0; i < N; i++) {
        scanf("%d", &featurePriorities[i]); // 读取每个特性的优先级
    }

    // 动态分配存储测试用例的数组
    TestCase *testCases = (TestCase *)malloc(M * sizeof(TestCase));
    for (int i = 0; i < M; i++) {
        int prioritySum = 0;
        // 计算每个测试用例的优先级总和
        for (int j = 0; j < N; j++) {
            int feature;
            scanf("%d", &feature); // 读取每个特性
            prioritySum += featurePriorities[feature - 1]; // 根据特性计算优先级总和
        }
        // 存储测试用例的ID和优先级总和
        testCases[i].id = i + 1;
        testCases[i].priority = prioritySum;
    }

    // 使用qsort对测试用例数组进行排序
    qsort(testCases, M, sizeof(TestCase), compare);

    // 输出排序后的测试用例ID
    for (int i = 0; i < M; i++) {
        printf("%d\n", testCases[i].id);
    }

    // 释放内存
    free(featurePriorities);
    free(testCases);

    return 0;
}

java算法源码

import java.util.*;

// 定义一个测试用例类
class TestCase implements Comparable<TestCase> {
    int id;          // 测试用例的ID
    int priority;    // 测试用例的优先级

    // 构造函数
    public TestCase(int id, int priority) {
        this.id = id;
        this.priority = priority;
    }

    // 实现compareTo方法，用于排序
    @Override
    public int compareTo(TestCase other) {
        if (priority != other.priority) return Integer.compare(other.priority, priority);
        return Integer.compare(id, other.id);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int N = scanner.nextInt(); // N是特性的数量
        int M = scanner.nextInt(); // M是测试用例的数量
        scanner.nextLine(); // 消耗换行符

        int[] featurePriorities = new int[N]; // 存储每个特性的优先级
        for (int i = 0; i < N; ++i) {
            featurePriorities[i] = scanner.nextInt(); // 读取特性的优先级
        }
        scanner.nextLine(); // 消耗换行符

        List<TestCase> testCases = new ArrayList<>(); // 存储所有的测试用例
        for (int i = 0; i < M; ++i) {
            String line = scanner.nextLine(); // 读取一行输入
            Scanner lineScanner = new Scanner(line);

            int prioritySum = 0, feature; // prioritySum用于计算测试用例的总优先级
            while (lineScanner.hasNext()) { // 读取测试用例涉及的每个特性
                feature = lineScanner.nextInt();
                prioritySum += featurePriorities[feature - 1]; // 计算总优先级
            }

            testCases.add(new TestCase(i + 1, prioritySum)); // 创建测试用例并加入到List中
        }

        // 根据优先级和ID对测试用例进行排序
        Collections.sort(testCases);

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

        scanner.close();
    }
}