1095 解码 PAT 准考证

PAT 准考证号由 4 部分组成：

第 1 位是级别，即 T 代表顶级；A 代表甲级；B 代表乙级；
第 2~4 位是考场编号，范围从 101 到 999；
第 5~10 位是考试日期，格式为年、月、日顺次各占 2 位；
最后 11~13 位是考生编号，范围从 000 到 999。

现给定一系列考生的准考证号和他们的成绩，请你按照要求输出各种统计信息。

输入格式：

输入首先在一行中给出两个正整数 N（≤104）和 M（≤100），分别为考生人数和统计要求的个数。

接下来 N 行，每行给出一个考生的准考证号和其分数（在区间 [0,100] 内的整数），其间以空格分隔。

考生信息之后，再给出 M 行，每行给出一个统计要求，格式为：类型指令，其中

类型 为 1 表示要求按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母；
类型 为 2 表示要求将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号；
类型 为 3 表示要求将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。

输出格式：

对每项统计要求，首先在一行中输出 Case #: 要求，其中 # 是该项要求的编号，从 1 开始；要求 即复制输入给出的要求。随后输出相应的统计结果：

类型 为 1 的指令，输出格式与输入的考生信息格式相同，即 准考证号成绩。对于分数并列的考生，按其准考证号的字典序递增输出（题目保证无重复准考证号）；
类型 为 2 的指令，按 人数总分 的格式输出；
类型 为 3 的指令，输出按人数非递增顺序，格式为 考场编号总人数。若人数并列则按考场编号递增顺序输出。

如果查询结果为空，则输出 NA。

输入样例：

tex

8 4
B123180908127 99
B102180908003 86
A112180318002 98
T107150310127 62
A107180908108 100
T123180908010 78
B112160918035 88
A107180908021 98
1 A
2 107
3 180908
2 999

8 4
B123180908127 99
B102180908003 86
A112180318002 98
T107150310127 62
A107180908108 100
T123180908010 78
B112160918035 88
A107180908021 98
1 A
2 107
3 180908
2 999

输出样例：

tex

Case 1: 1 A
A107180908108 100
A107180908021 98
A112180318002 98
Case 2: 2 107
3 260
Case 3: 3 180908
107 2
123 2
102 1
Case 4: 2 999
NA

Case 1: 1 A
A107180908108 100
A107180908021 98
A112180318002 98
Case 2: 2 107
3 260
Case 3: 3 180908
107 2
123 2
102 1
Case 4: 2 999
NA

Solution：

WARNING

测试点 2、3、5 运行超时

java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] input = in.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String[] x = in.readLine().split(" ");
            students.add(new Student(x[0], Integer.parseInt(x[1])));
        }
        String[][] points = new String[m + 1][];
        for (int i = 1; i <= m; i++) {
            int flag = 0;
            points[i] = in.readLine().split(" ");
            switch (points[i][0]) {
                case "1":
                    students.sort(null);
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    for (Student s : students) {
                        if (s.num.startsWith(points[i][1].charAt(0) + "")) {
                            flag = 1;
                            System.out.printf("%s %d\n", s.num, s.score);
                        }
                    }
                    if (flag == 0) {
                        System.out.println("NA");
                    }
                    break;
                case "2":
                    int person = 0, totalScore = 0;
                    for (Student s : students) {
                        if (s.num.substring(1, 4).equals(points[i][1])) {
                            flag = 1;
                            person++;
                            totalScore += s.score;
                        }
                    }
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    switch (flag) {
                        case 1:
                            System.out.printf("%d %d\n", person, totalScore);
                            break;
                        default:
                            System.out.println("NA");
                            break;
                    }

                    break;
                case "3":
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    List<Type3> list = new ArrayList<>();
                    int[] classroom = new int[1000];
                    for (Student s : students) {
                        if (s.num.substring(4, 10).equals(points[i][1])) {
                            classroom[Integer.parseInt(s.num.substring(1, 4))]++;
                        }
                    }
                    for (int j = 0; j < classroom.length; j++) {
                        if (classroom[j] > 0) {
                            list.add(new Type3(j, classroom[j]));
                        }
                    }
                    list.sort(null);
                    for (Type3 t : list) {
                        flag = 1;
                        System.out.printf("%d %d\n", t.classroom, t.num);
                    }
                    if (flag == 0) {
                        System.out.println("NA");
                    }
                    break;
            }
        }
    }

}

class Student implements Comparable<Student> {
    String num;
    int score;

    public Student(String num, int score) {
        super();
        this.num = num;
        this.score = score;
    }

    @Override
    public int compareTo(Student o) {
        return o.score - this.score != 0 ? o.score - this.score : this.num.compareTo(o.num);
    }

}

class Type3 implements Comparable<Type3> {
    int classroom;
    int num;

    public Type3(int classroom, int num) {
        super();
        this.classroom = classroom;
        this.num = num;
    }

    @Override
    public int compareTo(Type3 o) {
        return o.num - this.num != 0 ? o.num - this.num : this.classroom - o.classroom;
    }

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public class Main {

    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String[] input = in.readLine().split(" ");
        int n = Integer.parseInt(input[0]);
        int m = Integer.parseInt(input[1]);
        List<Student> students = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            String[] x = in.readLine().split(" ");
            students.add(new Student(x[0], Integer.parseInt(x[1])));
        }
        String[][] points = new String[m + 1][];
        for (int i = 1; i <= m; i++) {
            int flag = 0;
            points[i] = in.readLine().split(" ");
            switch (points[i][0]) {
                case "1":
                    students.sort(null);
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    for (Student s : students) {
                        if (s.num.startsWith(points[i][1].charAt(0) + "")) {
                            flag = 1;
                            System.out.printf("%s %d\n", s.num, s.score);
                        }
                    }
                    if (flag == 0) {
                        System.out.println("NA");
                    }
                    break;
                case "2":
                    int person = 0, totalScore = 0;
                    for (Student s : students) {
                        if (s.num.substring(1, 4).equals(points[i][1])) {
                            flag = 1;
                            person++;
                            totalScore += s.score;
                        }
                    }
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    switch (flag) {
                        case 1:
                            System.out.printf("%d %d\n", person, totalScore);
                            break;
                        default:
                            System.out.println("NA");
                            break;
                    }

                    break;
                case "3":
                    System.out.printf("Case %d: %s %s\n", i, points[i][0], points[i][1]);
                    List<Type3> list = new ArrayList<>();
                    int[] classroom = new int[1000];
                    for (Student s : students) {
                        if (s.num.substring(4, 10).equals(points[i][1])) {
                            classroom[Integer.parseInt(s.num.substring(1, 4))]++;
                        }
                    }
                    for (int j = 0; j < classroom.length; j++) {
                        if (classroom[j] > 0) {
                            list.add(new Type3(j, classroom[j]));
                        }
                    }
                    list.sort(null);
                    for (Type3 t : list) {
                        flag = 1;
                        System.out.printf("%d %d\n", t.classroom, t.num);
                    }
                    if (flag == 0) {
                        System.out.println("NA");
                    }
                    break;
            }
        }
    }

}

class Student implements Comparable<Student> {
    String num;
    int score;

    public Student(String num, int score) {
        super();
        this.num = num;
        this.score = score;
    }

    @Override
    public int compareTo(Student o) {
        return o.score - this.score != 0 ? o.score - this.score : this.num.compareTo(o.num);
    }

}

class Type3 implements Comparable<Type3> {
    int classroom;
    int num;

    public Type3(int classroom, int num) {
        super();
        this.classroom = classroom;
        this.num = num;
    }

    @Override
    public int compareTo(Type3 o) {
        return o.num - this.num != 0 ? o.num - this.num : this.classroom - o.classroom;
    }

}

1095 解码 PAT 准考证 ​

输入格式： ​

输出格式： ​

输入样例： ​

输出样例： ​

Solution： ​