1095 解码PAT准考证 (25 分) (JAVA)

JAVA解题最后三个测试点超时

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

第 1 位是级别，即 T 代表顶级；A 代表甲级；B 代表乙级；
第 2~4 位是考场编号，范围从 101 到 999；
第 5~10 位是考试日期，格式为年、月、日顺次各占 2 位；
最后 11~13 位是考生编号，范围从 000 到 999。
现给定一系列考生的准考证号和他们的成绩，请你按照要求输出各种统计信息。

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

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

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

类型 为 1 表示要求按分数非升序输出某个指定级别的考生的成绩，对应的 指令 则给出代表指定级别的字母；
类型 为 2 表示要求将某指定考场的考生人数和总分统计输出，对应的 指令 则给出指定考场的编号；
类型 为 3 表示要求将某指定日期的考生人数分考场统计输出，对应的 指令 则给出指定日期，格式与准考证上日期相同。
输出格式：
对每项统计要求，首先在一行中输出 Case #: 要求，其中 # 是该项要求的编号，从 1 开始；要求 即复制输入给出的要求。随后输出相应的统计结果：

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

输入样例：

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

输出样例：

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

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main{
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String array [] = br.readLine().split(" ");
        int a = Integer.valueOf(array[0]);
        int b = Integer.parseInt(array[1]);
        Information [] info = new Information[a];//存入准考信息
        for (int i = 0; i < a; i++) {
            info[i] = new Information(br.readLine());
        }
        Operate [] op = new Operate[b];//存入操作
        for (int i = 0; i < b; i++) {
            op[i] = new Operate(br.readLine());
        }
        Arrays.sort(info);//按照成绩降序，准考证升序排序
        for (int i = 0; i < b; i++){
            if(op[i].number==1){//比较级别level
                int temp = 0;
                System.out.println("Case " + (i + 1) + ": " + op[i].number + " " + op[i].operate);
                for (int j = 0; j < a; j++) {
                    if(info[j].level.equals(op[i].operate)){
                        if(temp==0){ temp++; }
                        System.out.println(info[j].toString()+" "+info[j].grade);
                    }
                }
                if(temp==0){
                    System.out.println("NA");
                }
            }else if(op[i].number==2){//比较考场编号
                int people = 0;
                int sum = 0;
                int temp = 0;
                System.out.println("Case "+(i+1)+": "+op[i].number+" "+op[i].operate);
                for (int j = 0; j < a; j++) {
                    if (info[j].number1.equals(op[i].operate)){
                        sum += info[j].grade;
                        people++;
                        temp++;
                    }
                }
                if(temp==0){
                    System.out.println("NA");
                }else{
                    System.out.printf("%d %d\n", people, sum);
                }
            }else if(op[i].number==3){//比较日期
                List<Compare> list1 = new ArrayList<>();
                System.out.println("Case "+(i+1)+": "+op[i].number+" "+op[i].operate);
                for (int j = 0; j < a; j++) {
                    String number1 = info[j].number1;
                    if(op[i].operate.equals(info[j].date)){
                        boolean ok = false;
                        if(list1.size()!=0){
                            for (int k = 0; k < list1.size(); k++) {//寻找是否list中有重复的值
                                if (list1.get(k).number1.equals(number1)) {//找到了
                                    ok = true;
                                    list1.get(k).sum++;//对应位置的sum值+1
                                    break;
                                }
                            }
                        }
                        if(!ok){//没找到，在list中新增一个元素
                            list1.add(new Compare(info[j].number1, 1));
                        }
                    }
                }
                if(list1.size() == 0){//如果list为空
                    System.out.println("NA");
                }else{
                    Collections.sort(list1);//排序按照人数降序，考场号升序
                    for (Compare com: list1){
                        System.out.println(com);
                    }
                }
            }
        }
    }
}
class Information implements Comparable<Information>{
    public String level;//级别
    public String number1;//考场编号
    public String date;//日期
    public String number2;//考生编号
    public int grade;//成绩
    public Information(String string){
        this.level = string.substring(0,1);
        this.number1 = string.substring(1,4);
        this.date = string.substring(4,10);
        this.number2 = string.substring(10,13);
        this.grade = Integer.parseInt(string.substring(14));
    }
    public int compareTo(Information info){//成绩降序,准考证升序
        if(this.grade>info.grade){
            return -1;
        }else if(this.grade<info.grade){
            return 1;
        }else{
            return this.toString().compareTo(info.toString());
        }
    }

    @Override
    public String toString() {
        return this.level+this.number1+this.date+this.number2;
    }
}
class Operate{
    public int number;
    public String operate;
    Operate(String string){
        String []s = string.split(" ");
        this.number = Integer.valueOf(s[0]);
        this.operate = s[1];
    }
}

class Compare implements Comparable<Compare>{
    public String number1;
    public int sum;

    public Compare(String number1, int sum) {
        this.number1 = number1;
        this.sum = sum;
    }

    @Override
    public int compareTo( Compare o) {//人数降序，考场靠升序排序
        if(this.sum > o.sum){
            return -1;//前大于后返回-1，降序
        }else if(this.sum < o.sum){
            return 1;
        }else{
            return this.number1.compareTo(o.number1);
        }
    }

    @Override
    public String toString() {
        return this.number1+" "+this.sum;
    }
}

最后三个测试点超时