【2023华为od-C卷-第二题-测试用例执行计划】100%通过率（JavaScript&Java&Python&C++）

本题已有网友报告代码100%通过率

OJ &答疑服务

购买任意专栏，即可添加博主vx:utheyi，获取答疑/辅导服务

OJ权限获取可以在购买专栏后访问网站：首页 - CodeFun2000

题目描述

某个产品当前迭代周期内有$N$个特性($F1,F2,....FN$)需要进行盖测试，每个特性都被评估了对应的优先级，特性使用其ID作为下标进行标识。
设计了$M$个测试用例($T1,T\mathrm{2.....}Tm$)，每个用例对应了一个覆盖特性的集合，测试用例使用其ID作为下标进行标识，测试用例的优先级定义为其覆盖的特性的优先级之和。
在开展测试之前，需要制定测试用例的执行顺序，规则为:优先级大的用例先执行，如果存在优先级相同的用例，用例ID小的先执行

输入描述

第一行输入为$N$和$M$，$N$表示特性的数量，$M$表示测试用例的数量($1\le N,M\le 100$)

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

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

输出描述

按照执行顺序 (优先级从大到小) 输出测试用例的ID，每行一个ID。测试用例覆盖的ID不重复。

样例1

输入

5 4
1
1
2
3
5
1 2 3
1 4
3 4 5
2 3 4

输出

3
4
1
2

样例2

输入

3 3
3
1
5
1 2 3
1 2 3
1 2 3

输出

1
2
3

思路：自定义排序

根据上述排序规则，对于每一个编号，根据其给定的优先级和数组每个元素的下标，对他的优先级进行求和，求和之后，按照题目要求的排序规则进行排序即可。

JavaScript

const readline = require('readline');  // 导入readline模块
const rl = readline.createInterface({  // 创建readline接口
  input: process.stdin,  // 从标准输入流中读取
  output: process.stdout  // 输出到标准输出流
});

let n, m;  // 声明变量n和m，用于存储输入的n和m的值
let inputCount = 0;  // 输入计数器，用于跟踪当前处理的输入行数
let w = [];  // 用于存储权重的数组
let lists = [];  // 用于存储处理后的数组

rl.on('line', (input) => {  // 当有新的一行输入时触发回调函数
  if (inputCount === 0) {  // 如果是第一行输入
    [n, m] = input.split(' ').map(Number);  // 将输入的n和m分割并转为数字赋给n和m
    w = new Array(n + 1).fill(0);  // 初始化存储权重的数组，长度为n+1，初始值为0
  } else if (inputCount <= n) {  // 如果是接下来的n行输入
    w[inputCount] = parseInt(input);  // 将输入的权重转为整数并存入对应位置的数组中
  } else {  // 如果是接下来的m行输入
    const arr = input.split(' ').map(x => w[parseInt(x)]);  // 将输入的数组转为对应的权重数组
    const _sum = arr.reduce((acc, val) => acc + val, 0);  // 计算数组的和
    lists.push([_sum, inputCount - n]);  // 将和及数组的索引信息存入lists数组
  }

  inputCount++;  // 输入计数器加1

  if (inputCount > n + m) {  // 如果所有输入处理完毕
    sortAndPrint(lists);  // 调用排序和打印函数
    rl.close();  // 关闭readline接口
  }
});

const sortAndPrint = (lists) => {  // 定义排序和打印函数
  lists.sort((a, b) => b[0] - a[0] || a[1] - b[1]);  // 对lists数组进行排序
  for (let l of lists) {  // 遍历排序后的lists数组
    console.log(l[1]);  // 打印数组中的第二个元素
  }
}

Python

n, m = map(int, input().split())  # 读取输入的整数n和m
w = [0] * (n + 1)  # 创建长度为n+1的整数列表w，初始值为0
for i in range(1, n + 1):
    w[i] = int(input())  # 读取n个整数并存入列表w
lists = [[] for _ in range(m)]  # 创建m个空列表的列表

for i in range(m):
    arr = [w[int(x)] for x in input().split()]  # 读取一行输入，将其按空格分割并转为整数列表arr
    _sum = sum(arr)  # 计算arr的和
    lists[i].append(_sum)  # 将和添加到lists的第i个元素中
    lists[i].append(i + 1)  # 将i+1添加到lists的第i个元素中

lists.sort(key=lambda x: (-x[0], x[1]))  # 对lists进行排序，首先按照第一个元素降序排序，然后按照第二个元素升序排序

for l in lists:
    print(l[-1])  # 输出lists的每个元素的最后一个值

C++

#include

using namespace std;

int main() {
    int n, m;
    cin >> n >> m;  // 读取输入的整数n和m
    vector<int> a(n + 1);  // 创建整数向量a，长度为n+1
    for (int i = 1; i <= n; i++)
        cin >> a[i];  // 读取n个整数并存入向量a
    vector<vector<int>> list(m, vector<int>());  // 创建整数向量的向量list，长度为m，每个元素为一个空的整数向量
    cin.ignore();  // 忽略换行符
    for (int i = 0; i < m; i++) {
        string s;
        getline(cin, s);  // 读取一行字符串
        istringstream iss(s);  // 创建字符串流
        vector<int> arr((istream_iterator<int>(iss)), istream_iterator<int>());  // 将字符串流转为整数向量arr
        for (int j = 0; j < arr.size(); j++)
            arr[j] = a[arr[j]];  // 将arr中的每个元素替换为向量a中对应索引的值
        int sum = accumulate(arr.begin(), arr.end(), 0);  // 计算arr的和
        list[i].push_back(sum);  // 将和添加到list的第i个元素中
        list[i].push_back(i + 1);  // 将i+1添加到list的第i个元素中
    }
    sort(list.begin(), list.end(), [](const auto &o1, const auto &o2) {  // 对list进行排序
        if (o1[0] != o2[0])
            return o1[0]>o2[0];
        return o1[1] < o2[1];
    });
    for (int i = 0; i < m; i++)
        cout << list[i].back() << endl;  // 输出list的第i个元素的最后一个值
    return 0;
}

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  // 创建Scanner对象用于接收输入
        int n = sc.nextInt();  // 读取输入的整数n
        int m = sc.nextInt();  // 读取输入的整数m
        int[] a = new int[n + 1];  // 创建整数数组a，长度为n+1
        for (int i = 1; i <= n; i++)
            a[i] = sc.nextInt();  // 读取n个整数并存入数组a
        List<Integer>[] list = new ArrayList[m];  // 创建整数列表的数组list，长度为m
        for (int i = 0; i < m; i++)
            list[i] = new ArrayList<>();  // 初始化数组list的每个元素为一个空的整数列表
        sc.nextLine();  // 读取换行符，准备读取下一行输入
        for (int i = 0; i < m; i++) {
            String s = sc.nextLine();  // 读取一行字符串
            int[] arr = Arrays.stream(s.split(" ")).mapToInt(Integer::parseInt).toArray();  // 将字符串按空格分割并转为整数数组
            for (int j = 0; j < arr.length; j++)
                arr[j] = a[arr[j]];  // 将整数数组arr中的每个元素替换为数组a中对应索引的值
            int sum = Arrays.stream(arr).sum();  // 计算整数数组arr的和
            list[i].add(sum);  // 将和添加到数组list的第i个元素中
            list[i].add(i + 1);  // 将i+1添加到数组list的第i个元素中
        }
        Arrays.sort(list, (o1, o2) -> {  // 对数组list进行排序
            if (o1.get(0) != o2.get(0))
                return o2.get(0) - o1.get(0);
            return o1.get(1) - o2.get(1);
        });
        for (int i = 0; i < m; i++)
            System.out.println(list[i].get(list[i].size() - 1));  // 输出数组list的第i个元素的最后一个值
    }
}