1095 解码 PAT 准考证 （25 分）（得分16，后三个测试超时）

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。

代码：

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

public class Main {
	public static void main(String[] org) throws IOException {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		String[] s = bf.readLine().split("\\s+");
		int N = Integer.parseInt(s[0]);
		int M = Integer.parseInt(s[1]);
		List<KS> list = new ArrayList<KS>();
		for (int i = 0; i < N; i++) {
			String[] s1 = bf.readLine().split("\\s+");
			String[] s2 = s1[0].split("");
			KS ks = new KS(s2, Integer.parseInt(s1[1]));
			list.add(ks);
		}
		List<ZL> list1 = new ArrayList<ZL>();
		for (int i = 0; i < M; i++) {
			String[] s1 = bf.readLine().split("\\s+");
			ZL zl = new ZL(Integer.parseInt(s1[0]), s1[1]);
			list1.add(zl);
		}
		bf.close();
		for (int i = 1; i < M + 1; i++) {
			int n = list1.get(i - 1).n;
			ZL zl = list1.get(i - 1);
			System.out.println("Case" + " " + i + ":" + " " + n + " " + zl.z);
			switch (n) {
			case 1: {
				String ss = zl.z;
				List<KS> list2 = new ArrayList<KS>();
				for (int j = 0; j < N; j++) {
					KS k1 = list.get(j);
					if (k1.jb.equals(ss)) {
						list2.add(k1);
					}
				}
				if (list2.size() == 0) {
					System.out.println("NA");
					break;
				}
				Collections.sort(list2);
				for (int j = 0; j < list2.size(); j++) {
					System.out.println(list2.get(j).kh+ " " + list2.get(j).gra);
				}
				break;
			}
			case 2: {
				int sum = 0;
				int num = 0;
				for (int j = 0; j < N; j++) {
					KS k1 = list.get(j);
					if (k1.kc == Integer.parseInt(zl.z)) {
						sum = sum + k1.gra;
						num++;
					}
				}
				if (num == 0) {
					System.out.println("NA");
					break;
				}
				System.out.println(num + " " + sum);
				break;
			}
			case 3: {
				List<KC> list2 = new ArrayList<KC>();
				int date = Integer.parseInt(zl.z);
				for (int j = 0; j < N; j++) {
					KS ks = list.get(j);
					if (ks.date == date) {
						boolean b = false;
						if (list2.size() != 0) {
							for (int k = 0; k < list2.size(); k++) {
								if (list2.get(k).num == ks.kc) {
									b = true;
									list2.get(k).sum++;
									break;
								}
							}
						}
						if (!b) {
							KC kc = new KC(ks.kc, 1);
							list2.add(kc);
						}
					}
				}
				if (list2.size() == 0) {
					System.out.println("NA");
					break;
				}
				Collections.sort(list2);
				for (int k = 0; k < list2.size(); k++) {
					KC kc = list2.get(k);
					System.out.println(kc.num + " " + kc.sum);
				}

				break;
			}
			}
		}
	}

	public static class KC implements Comparable<KC> {
		public int num;
		public int sum;

		public KC(int num, int sum) {
			this.num = num;
			this.sum = sum;
		}

		public void Sum(int n) {
			sum = sum + n;
		}

		@Override
		public int compareTo(KC o) {
			// TODO Auto-generated method stub
			if (this.sum < o.sum) {
				return 1;
			}
			if (this.sum > o.sum) {
				return -1;
			}
			if (this.sum == o.sum) {
				return this.num - o.num;
			}
			return 0;
		}
	}

	public static class ZL {
		public int n;
		public String z;

		public ZL(int n, String z) {
			this.n = n;
			this.z = z;
		}
	}

	public static class KS implements Comparable<KS> {
		public String[] KH;
		public String kh;
		public int gra;
		public String jb;
		public int kc;
		public int date;
		public int num;

		public KS() {

		}

		public KS(String[] KH, int gra) {
			this.KH = KH;
			this.gra = gra;
			this.jb = KH[0];
			String s = "";
			for (int i = 0; i < KH.length; i++) {
				s = s + KH[i];
			}
			this.kh = s;
			s = "";
			for (int i = 1; i < 4; i++) {
				s = s + KH[i];
			}
			this.kc = Integer.parseInt(s);
			s = "";
			for (int i = 4; i < 10; i++) {
				s = s + KH[i];
			}
			this.date = Integer.parseInt(s);
			s = "";
			for (int i = 10; i < 13; i++) {
				s = s + KH[i];
			}
			this.num = Integer.parseInt(s);
		}

		@Override
		public int compareTo(KS o) {
			// TODO Auto-generated method stub
			if (this.gra < o.gra) {
				return 1;
			}
			if (this.gra > o.gra) {
				return -1;
			}
			if (this.gra == o.gra) {
				return this.kh.compareTo(o.kh);
			}
			return 0;
		}
	}
}